base.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_BASE_HPP_H_
#define CCF_COMMON_BASE_HPP_H_
 
#include <boost/exception/diagnostic_information.hpp>
 
#include <Recif.hpp>
#include <ctd/defines/defines.hpp>
#include <ctd/system/system.hpp>
#include <ctd/time/time.hpp>
#include <ctd/conversion/conversion.hpp>
 
#include <ccf/mptk/manager.hpp>
 
namespace ccf::common {
 
  const std::string CCF_VERSION = "1.0.0";
 
  const std::string IFW_VERSION = "3.0";
 
  // @{
  const std::string DB_NODE_SM_STATUS_STATE       = "sm.status.state";
  const std::string DB_NODE_SM_STATUS_SUBSTATE    = "sm.status.substate";
  const std::string DB_NODE_SM_STATE              = "sm.state";
  // @}
 
  // @{
  const std::string META_KEY_EXPO_RATE            = "MetaExpoType";
  const std::string META_KEY_EXPO_TIME            = "MetaExpoTime";
  const std::string META_KEY_EXPO_WIN_BINX        = "MetaExpoWinBinX";
  const std::string META_KEY_EXPO_WIN_BINY        = "MetaExpoWinBinY";
  const std::string META_KEY_EXPO_WIN_STARTX      = "MetaExpoWinStartX";
  const std::string META_KEY_EXPO_WIN_STARTY      = "MetaExpoWinStartY";
  const std::string META_KEY_SYSTEM               = "MetaSystem";
  const std::string META_KEY_CAM_NAME             = "MetaCamName";
  const std::string META_KEY_CAM_ID               = "MetaCamId";
  const std::string META_KEY_CAM_MODEL            = "MetaCamModel";
  const std::string META_KEY_CAM_CHIPMODEL        = "MetaCamChipModel";
  const std::string META_KEY_CAM_TYPE             = "MetaCamType";
  // @}
 
  // @{
  const std::string STATE_ON_NOT_OP_NOT_READY    = "On::NotOperational::NotReady";
  const std::string STATE_ON_NOT_OP_READY        = "On::NotOperational::Ready";
  const std::string STATE_ON_OP_IDLE             = "On::Operational::Idle";
  const std::string STATE_ON_OP_ACQ              = "On::Operational::Acquisition";
  const std::string STATE_ON_OP_ACQ_NOT_REC      = "On::Operational::Acquisition::NotRecording";
  const std::string STATE_ON_OP_ACQ_REC          = "On::Operational::Acquisition::Recording";
  // @}
 
  enum class LogLevel {
      OFF               = 60000,
      FATAL             = 50000,
      ERROR             = 40000,
      WARN              = 30000,
      INFO              = 20000,
      DEBUG             = 10000,
      DEBUG2            = 9000,
      DEBUG3            = 8000,
      TRACE             = 0,
      ALL               = TRACE,
      NOT_SET           = -1
  };
 
  void SendThrMsg(const std::string& command,
                  const std::string& sender_thread_id,
                  const std::string& receiver_thread_id,
                  const std::string& data);
 
  bool ReceiveThrMsg(const std::string& receiver_thread_id,
                     const double time_out,
                     ccf::mptk::Message& message);
 
  void DecomposeSmStatus(const std::string& sm_state,
                         std::string& sum_state,
                         std::string& sum_substate);
 
  class Base {
  public:
 
    static ccf::mptk::Manager& Mptk() {
        return s_mptk_mgr;
    }
 
    static void SetLogLevel(const ccf::common::LogLevel log_level);
 
    static ccf::common::LogLevel GetLogLevel();
 
    Base();
    ~Base();
 
    const std::string& GetClassName() const;
 
  protected:
    void SetClassName(const std::string& class_name);
 
  private:
    static ccf::mptk::Manager     s_mptk_mgr;
    static ccf::common::LogLevel  s_log_level;
    std::string                   m_class_name;
  };
 
  const std::string CFG_KEY_SYS_IMAGE_DIR = "sys.image.dir";
 
  void AssertPtr(const void* ptr,
                 const std::string& object,
                 const std::string& location);
 
  enum class HwStatus {
    NOT_OK = 0,
    OK
  };
 
  enum class Status {
    FAILURE = 0,
    SUCCESS = 1
  };
 
  // @{
  const std::string SUCCESS = "Success";
  const std::string FAILURE = "Failure";
  // @}
 
  std::string StatusToStr(ccf::common::Status status);
 
  enum class ImageDataType {
    UNKNOWN     =  -1,
    BYTE        =   8,  // 8 bit
    PRESCALED   =  -8,  // Prescaled
    INT16       =  16,  // 16 bit signed
    UINT16      = -16,  // 16 bit unsigned
    INT32       =  32,  // 32 bit integer
    FLOAT       = -32,  // 32 bit floating point
    INT64       =  64,  // 64 bit integer (long long int)
    DOUBLE      = -64   // 64 bit double precision
  };
 
  enum class PubType {
    UNDEFINED = -1,
    RECORDING = 1,
    NOT_RECORDING
  };
 
  enum class PubStatus {
    ACTIVE     = recif::RecStatusNames::Active,
    COMPLETED  = recif::RecStatusNames::Completed,
    STOPPED    = recif::RecStatusNames::Stopped,
    ABORTED    = recif::RecStatusNames::Aborted,
    FAILED     = recif::RecStatusNames::Failed,
    UNDEFINED  = recif::RecStatusNames::Undefined
  };
 
  void ResetRecStatusObj(std::shared_ptr<recif::RecStatus>& rec_status_obj,
                         const recif::RecStatusNames rec_status = recif::RecStatusNames::Undefined);
 
  void CopyRecStatusObj(const std::shared_ptr<recif::RecStatus>& src_rec_status_obj,
                        const std::shared_ptr<recif::RecStatus>& trg_rec_status_obj);
 
  enum class ProcStatus {
    UNDEFINED  = -1,
    IDLE       = 1,
    PROCESSING = 32,
    FINISHED   = 128,
    FAILED     = 256
  };
 
  // TODO: Change name to Acquisition Mode.
  enum class ExpoMode {
    FINITE = 1,
    CONTINUOUS,
    INACTIVE
  };
  
  // @{
  const std::string SETUP_KEY_EXPO_TIME              = "expo.time";
  const std::string SETUP_KEY_EXPO_MODE              = "expo.mode";
  const std::string SETUP_KEY_EXPO_NB                = "expo.nb";
  const std::string SETUP_KEY_EXPO_WIN_START_X       = "expo.win.start_x";
  const std::string SETUP_KEY_EXPO_WIN_START_Y       = "expo.win.start_y";
  const std::string SETUP_KEY_EXPO_WIN_WIDTH         = "expo.win.width";
  const std::string SETUP_KEY_EXPO_WIN_HEIGHT        = "expo.win.height";
  const std::string SETUP_KEY_EXPO_BIN_X             = "expo.bin_x";
  const std::string SETUP_KEY_EXPO_BIN_Y             = "expo.bin_y";
  const std::string SETUP_KEY_EXPO_FRAME_RATE        = "expo.frame.rate";
  const std::string SETUP_KEY_EXPO_FRAME_RATE_LIMIT  = "expo.frame.rate.limit";
  const std::string SETUP_KEY_SIM_TYPE               = "sim.type";
  const std::string SETUP_KEY_SIM_FILE               = "sim.file";
  const std::string SETUP_KEY_SIM_MAX_SHIFT_PR_FRAME = "sim.max_shift_pr_frame";
  const std::string SETUP_KEY_SIM_MAX_SHIFT          = "sim.max_shift";
  const std::string SETUP_KEY_SIM_NOISE              = "sim.noise";
  const std::string SETUP_KEY_PROC_ENABLED           = "proc%d.enabled";
  // @}
 
  const std::string PROP_KEY_FRAME_RATE_LIMIT        = "expo.frame.rate.limit";
 
  // @{
  const std::string EXPO_MODE_FINITE                 = "Finite";
  const std::string EXPO_MODE_CONTINUOUS             = "Continuous";
  const std::string EXPO_MODE_INACTIVE               = "Inactive";
  // @}
 
  // Prefix prepended to Recording Session IDs.
  const std::string REC_ID_PREFIX                    = "RecId";
 
  ExpoMode ExpoModeToNb(const std::string& expo_mode);
 
  enum class SimType {
    FILE = 1,
    PATTERN1
  };
 
  // @{
  const std::string SIM_TYPE_FILE_STR       = "File";
  const std::string SIM_TYPE_PATTERN1_STR   = "Pattern1";
  // @}
 
  // @{
  const std::string PUB_STAT_NAME_ACTIVE    = "Active";
  const std::string PUB_STAT_NAME_COMPLETED = "Completed";
  const std::string PUB_STAT_NAME_STOPPED   = "Stopped";
  const std::string PUB_STAT_NAME_ABORTED   = "Aborted";
  const std::string PUB_STAT_NAME_FAILED    = "Failed";
  const std::string PUB_STAT_NAME_UNDEFINED = "Undefined";
  // @}
 
  std::string RecStatusNameToStr(recif::RecStatusNames rec_status_nb);
 
  std::string PubStatusNameToStr(PubStatus pub_status_nb);
 
  LogLevel LogLevelStrToNb(const std::string& log_level);
}
 
log4cplus::Logger& CcfLogger();
 
log4cplus::Logger& CcfLogger2();
 
log4cplus::Logger& CcfLogger3();
 
inline std::string CcfThreadName() {
  char thread_name[32];
  pthread_getname_np(pthread_self(), thread_name, 32);
  return thread_name;
}
 
#define CCFLOC (std::string(__FILE__) + ":" + std::to_string(__LINE__) + ":" + \
                std::string(__FUNCTION__) + ":" + CcfThreadName())
 
class CCF_TRACE_CLASS {
  public:
    static int8_t        s_nesting_level;
    static std::string   s_padding_chars;
 
    CCF_TRACE_CLASS(const std::string& location,
                    const std::string& scope = "") {
      if (s_nesting_level == -2) {
        s_nesting_level = -1;
        s_padding_chars = "********************************************************************************"
                          "********************";
      }
      s_nesting_level++;
      m_time_at_scope_entry = ctd::time::Time();
      m_location = location;
      m_scope = scope;
      m_id = ctd::defines::GenUniqueId();
      if (scope != "") {
        LOG4CPLUS_TRACE(CcfLogger(), (s_padding_chars.substr(0, s_nesting_level) + "ENTERING:" + m_id + ": " +
                        location + ":" + scope));
      } else {
        LOG4CPLUS_TRACE(CcfLogger(), (s_padding_chars.substr(0, s_nesting_level) + "ENTERING:" + m_id + ": " + location));
      }
    };
 
    ~CCF_TRACE_CLASS() {
      if (m_scope != "") {
        LOG4CPLUS_TRACE(CcfLogger(), (s_padding_chars.substr(0, s_nesting_level) + "LEAVING:" + m_id + ": " +
                        m_location + ":" + m_scope + " (" + 
                        ctd::conversion::NbToStr((ctd::time::Time() - m_time_at_scope_entry), "%.6E") + " s)"));
      } else {
        LOG4CPLUS_TRACE(CcfLogger(), (s_padding_chars.substr(0, s_nesting_level) + "LEAVING:" + m_id + ": " +
                        m_location + " (" + 
                        ctd::conversion::NbToStr((ctd::time::Time() - m_time_at_scope_entry), "%.6E") + " s)"));
      }
      s_nesting_level--;
    };
 
  protected:
 
  private:
    double m_time_at_scope_entry;
    std::string m_location;
    std::string m_scope;
    std::string m_id;
};
 
inline void CcfDebug(const std::string& location,
                     const std::string& msg) {
    fprintf(stdout, "%s:%s#> %s\n", ctd::time::IsoTimeNow().c_str(), location.c_str(), msg.c_str());
    fflush(stdout);
}
 
 
#define INFO_LOG_GUARD   if (ccf::common::Base::GetLogLevel() <= ccf::common::LogLevel::INFO)
 
#define DEBUG_LOG_GUARD  if (ccf::common::Base::GetLogLevel() <= ccf::common::LogLevel::DEBUG)
 
#define DEBUG2_LOG_GUARD if (ccf::common::Base::GetLogLevel() <= ccf::common::LogLevel::DEBUG2)
 
#define DEBUG3_LOG_GUARD if (ccf::common::Base::GetLogLevel() <= ccf::common::LogLevel::DEBUG3)
 
#define TRACE_LOG_GUARD  if (ccf::common::Base::GetLogLevel() <= ccf::common::LogLevel::TRACE)
 
 
#define CCFERROR(msg)                       LOG4CPLUS_ERROR(CcfLogger(),  CCFLOC << ": " << msg)
 
#define CCFWARNING(msg)                     LOG4CPLUS_WARN(CcfLogger(),   CCFLOC << ": " << msg)
 
#define CCFSTATE(msg)                       LOG4CPLUS_STATE(CcfLogger(),  CCFLOC << ": " << msg)
 
#define CCFEVENT(msg)                       LOG4CPLUS_EVENT(CcfLogger(),  CCFLOC << ": " << msg)
 
#define CCFACTION(msg)                      LOG4CPLUS_ACTION(CcfLogger(), CCFLOC << ": " << msg)
 
#define CCFINFO(msg)     INFO_LOG_GUARD   { LOG4CPLUS_INFO(CcfLogger(),   CCFLOC << ": " << msg); }
 
#define CCFDEBUG(msg)    DEBUG_LOG_GUARD  { LOG4CPLUS_DEBUG(CcfLogger(),  CCFLOC << ": " << msg); }
 
#define CCFDEBUG2(msg)   DEBUG2_LOG_GUARD { LOG4CPLUS_DEBUG(CcfLogger2(), CCFLOC << ": " << msg); }
 
#define CCFDEBUG3(msg)   DEBUG3_LOG_GUARD { LOG4CPLUS_DEBUG(CcfLogger3(), CCFLOC << ": " << msg); }
 
#define CCFTRACE         TRACE_LOG_GUARD  { CCF_TRACE_CLASS _trace(CCFLOC, ""); }
 
#define CCFTRACEX(scope) TRACE_LOG_GUARD  { CCF_TRACE_CLASS _trace(CCFLOC, scope); }
 
 
#define CCFTHROW(msg)   throw rad::Exception(CCFLOC + ": " + msg)
 
#endif // CCF_COMMON_BASE_HPP_H_