base.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_BASE_HPP_H_
#define CCF_COMMON_BASE_HPP_H_
 
#include <fmt/format.h>
 
#include <boost/exception/diagnostic_information.hpp>
 
#include <Recif.hpp>
#include <core/utils/base/base.hpp>
#include <core/utils/system/system.hpp>
#include <core/utils/time/time.hpp>
#include <core/utils/conversion/conversion.hpp>
#include <utils/bat/config.hpp>
 
#include <ccf/mptk/manager.hpp>
#include <ccf/common/dataType.hpp>
 
namespace ccf {
  log4cplus::Logger& Logger();
 
  enum class LogLevel {
      OFF               = 0,
      FATAL             = 100,
      ERROR             = 200,
      WARN              = 300,
      INFO              = 400,
      DEBUG             = 500,
      DEBUG2            = 501,
      DEBUG3            = 502,
      TRACE             = 600,
      NOT_SET           = -1
  };
 
  // @{
  namespace loglevel {
    constexpr auto OFF     = "OFF";
    constexpr auto FATAL   = "FATAL";
    constexpr auto ERROR   = "ERROR";
    constexpr auto WARN    = "WARN";
    constexpr auto INFO    = "INFO";
    constexpr auto DEBUG   = "DEBUG";
    constexpr auto DEBUG2  = "DEBUG2";
    constexpr auto DEBUG3  = "DEBUG3";
    constexpr auto TRACE   = "TRACE";
  }
  // @}
 
  inline LogLevel LogLevelToNb(const std::string& log_level) {
    static std::map<std::string, LogLevel> s_log_level_str_to_nb_map =
      {{loglevel::OFF, LogLevel::OFF},       {loglevel::FATAL, LogLevel::FATAL},
       {loglevel::ERROR, LogLevel::ERROR},   {loglevel::WARN, LogLevel::WARN},
       {loglevel::INFO, LogLevel::INFO},     {loglevel::DEBUG, LogLevel::DEBUG},
       {loglevel::DEBUG2, LogLevel::DEBUG2}, {loglevel::DEBUG3, LogLevel::DEBUG3},
       {loglevel::TRACE, LogLevel::TRACE}};
    try {
      return s_log_level_str_to_nb_map[log_level];
    } catch (...) {
      throw std::runtime_error("Invalid log level given: " + log_level);
    }
  }
 
  inline std::string LogLevelToString(const LogLevel log_level) {
    static std::map<LogLevel, std::string> s_log_level_nb_to_str_map =
      {{LogLevel::OFF, loglevel::OFF},       {LogLevel::FATAL, loglevel::FATAL},
       {LogLevel::ERROR, loglevel::ERROR},   {LogLevel::WARN, loglevel::WARN},
       {LogLevel::INFO, loglevel::INFO},     {LogLevel::DEBUG, loglevel::DEBUG},
       {LogLevel::DEBUG2, loglevel::DEBUG2}, {LogLevel::DEBUG3, loglevel::DEBUG3},
       {LogLevel::TRACE, loglevel::TRACE}};
    return s_log_level_nb_to_str_map[log_level];
  }
 
  constexpr auto CCF_VERSION = "1.2.0";
 
  constexpr auto IFW_VERSION = "4.0";
 
  constexpr auto NO_VALUE = "__NO__VALUE__";
 
 
  const std::string DB_DELIM = std::string(utils::bat::CONFIG_DB_DELIMITER);
 
  // @{
  const std::string DB_NODE_SM_STATUS_STATE =
    ("sm" + DB_DELIM + "status" + DB_DELIM + "state");
  const std::string DB_NODE_SM_STATUS_SUBSTATE =
    ("sm" + DB_DELIM + "status" + DB_DELIM + "substate");
  const std::string DB_NODE_SM_STATE =
    ("sm" + DB_DELIM + "state");
  // @}
 
  // @{
  constexpr auto META_KEY_EXPO_RATE            = "MetaExpoType";
  constexpr auto META_KEY_EXPO_TIME            = "MetaExpoTime";
  constexpr auto META_KEY_EXPO_WIN_BINX        = "MetaExpoWinBinX";
  constexpr auto META_KEY_EXPO_WIN_BINY        = "MetaExpoWinBinY";
  constexpr auto META_KEY_EXPO_WIN_STARTX      = "MetaExpoWinStartX";
  constexpr auto META_KEY_EXPO_WIN_STARTY      = "MetaExpoWinStartY";
  constexpr auto META_KEY_SYSTEM               = "MetaSystem";
  constexpr auto META_KEY_CAM_NAME             = "MetaCamName";
  constexpr auto META_KEY_CAM_ID               = "MetaCamId";
  constexpr auto META_KEY_CAM_MODEL            = "MetaCamModel";
  constexpr auto META_KEY_CAM_CHIPMODEL        = "MetaCamChipModel";
  constexpr auto META_KEY_CAM_TYPE             = "MetaCamType";
  // @}
 
  // @{
  constexpr auto STATE_ON_NOT_OP_NOT_READY    = "On::NotOperational::NotReady";
  constexpr auto STATE_ON_NOT_OP_READY        = "On::NotOperational::Ready";
  constexpr auto STATE_ON_OP_IDLE             = "On::Operational::Idle";
  constexpr auto STATE_ON_OP_ACQ              = "On::Operational::Acquisition";
  constexpr auto STATE_ON_OP_ACQ_NOT_REC      = "On::Operational::Acquisition::NotRecording";
  constexpr auto STATE_ON_OP_ACQ_REC          = "On::Operational::Acquisition::Recording";
  // @}
 
  enum class ThreadType {
     MONITOR = 1,
     ACQUISITION,
     PROCESSING,
     PUBLISHER,
     UNDEFINED = -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::LogLevel log_level);
 
    static ccf::LogLevel GetLogLevel();
 
    Base();
    ~Base();
 
    const std::string& GetClassName() const;
 
    log4cplus::Logger& Loggger();
 
  protected:
    void SetClassName(const std::string& class_name);
 
    void SetLogger(log4cplus::Logger& logger);
 
    log4cplus::Logger m_logger;
 
  private:
    static ccf::mptk::Manager     s_mptk_mgr;
    static ccf::LogLevel          s_log_level;
    std::string                   m_class_name;
  };
 
  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
  };
 
  // @{
  constexpr auto SUCCESS = "Success";
  constexpr auto FAILURE = "Failure";
  // @}
 
  std::string StatusToStr(ccf::Status status);
 
  enum class Bitpix {
    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
  };
 
  inline DataTypes BitpixToDataType(const Bitpix bitpix) {
      switch (bitpix) {
        case Bitpix::BYTE:
          return DataTypes::BYTE;
        case Bitpix::INT16:
          return DataTypes::INT16;
        case Bitpix::UINT16:
          return DataTypes::UINT16;
        case Bitpix::INT32:
          return DataTypes::INT32;
        case Bitpix::FLOAT:
          return DataTypes::FLOAT;
        case Bitpix::INT64:
          return DataTypes::INT64;
        case Bitpix::DOUBLE:
          return DataTypes::DOUBLE;
        default:
          return DataTypes::INVALID;
      }
  }
 
  inline static Bitpix DataTypeToBitpix(const DataTypes data_type) {
    switch (data_type) {
      case DataTypes::BYTE:
        return Bitpix::BYTE;
        break;
      case DataTypes::INT16:
        return Bitpix::INT16;
        break;
      case DataTypes::UINT16:
        return Bitpix::UINT16;
        break;
      case DataTypes::INT32:
        return Bitpix::INT32;
        break;
      case DataTypes::FLOAT:
        return Bitpix::FLOAT;
        break;
      case DataTypes::DOUBLE:
        return Bitpix::DOUBLE;
        break;
      default:
        return Bitpix::UNKNOWN;
      }
  }
 
  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
  };
  
// @{
  constexpr auto CFG_NODE_ACQUISITION             = "acquisition";
  constexpr auto CFG_NODE_MONITORING              = "monitoring";
  constexpr auto CFG_NODE_PROCESSING              = "processing";
  constexpr auto CFG_NODE_RECORDING               = "recording";
  constexpr auto CFG_NODE_SERVER                  = "server";
  constexpr auto CFG_NODE_TASKS                   = "tasks";
 
  constexpr auto CFG_KEY_ADAPTER                  = "adapter";
  constexpr auto CFG_KEY_ADDRESS                  = "address";
  constexpr auto CFG_KEY_ALLOW_FRAME_SKIPPING     = "allow_frame_skipping";
  constexpr auto CFG_KEY_ALLOW_LOST_FRAMES        = "allow_lost_frames";
  constexpr auto CFG_KEY_DEVICES                  = "devices";
  constexpr auto CFG_KEY_HEIGHT                   = "height";
  constexpr auto CFG_KEY_ID                       = "id";
  constexpr auto CFG_KEY_IMAGE_DIR                = "image_dir";
  constexpr auto CFG_KEY_INIT_SETUP               = "init_setup";
  constexpr auto CFG_KEY_INPUT_QUEUE_SIZE         = "input_queue_size";
  constexpr auto CFG_KEY_MANUFACTURER             = "manufacturer";
  constexpr auto CFG_KEY_MAPPING                  = "mapping";
  constexpr auto CFG_KEY_MAX_RATE                 = "max_rate";
  constexpr auto CFG_KEY_MAX_RESOLUTION           = "max_resolution";
  constexpr auto CFG_KEY_METADATA_MAP             = "metadata_map";
  constexpr auto CFG_KEY_MODEL                    = "model";
  constexpr auto CFG_KEY_NAME                     = "name";
  constexpr auto CFG_KEY_NAMES                    = "names";
  constexpr auto CFG_KEY_NB_OF_SAMPLES            = "nb_of_samples";
  constexpr auto CFG_KEY_OUPUT_QUEUE_SIZE         = "output_queue_size";
  constexpr auto CFG_KEY_PERIOD                   = "period";
  constexpr auto CFG_KEY_PIPELINE                 = "pipeline";
  constexpr auto CFG_KEY_PROPERTIES               = "properties";
  constexpr auto CFG_KEY_PROTOCOL                 = "protocol";
  constexpr auto CFG_KEY_PUBLISHERS               = "publishers";
  constexpr auto CFG_KEY_RECIPES                  = "recipes";
  constexpr auto CFG_KEY_REC_HIST_EXP             = "rec_hist_expiration";
  constexpr auto CFG_KEY_REC_HIST_SIZE            = "rec_hist_size";
  constexpr auto CFG_KEY_RESOLUTION               = "resolution";
  constexpr auto CFG_KEY_SDK                      = "sdk";
  constexpr auto CFG_KEY_SIMULATION               = "simulation";
  constexpr auto CFG_KEY_SIM_ADDRESS              = "sim_address";
  constexpr auto CFG_KEY_TYPE                     = "type";
  constexpr auto CFG_KEY_VALUE                    = "value";
  constexpr auto CFG_KEY_WIDTH                    = "width";
// @}
 
  // @{
  constexpr auto SETUP_NODE_EXPO                  = "expo";
  constexpr auto SETUP_NODE_SIM                   = "sim";
 
  constexpr auto SETUP_KEY_ADDRESS                = "address";
  constexpr auto SETUP_KEY_BASENAME               = "basename";
  constexpr auto SETUP_KEY_BIN_X                  = "bin_x";
  constexpr auto SETUP_KEY_BIN_Y                  = "bin_y";
  constexpr auto SETUP_KEY_DELAY                  = "delay";
  constexpr auto SETUP_KEY_ENABLED                = "enabled";
  constexpr auto SETUP_KEY_FILE                   = "file";
  constexpr auto SETUP_KEY_FORMAT                 = "format";
  constexpr auto SETUP_KEY_FRAME_RATE             = "frame_rate";
  constexpr auto SETUP_KEY_FRAME_RATE_LIMIT       = "frame_rate_limit";
  constexpr auto SETUP_KEY_MAX_RATE               = "max_rate";
  constexpr auto SETUP_KEY_MAX_SHIFT              = "max_shift";
  constexpr auto SETUP_KEY_MAX_SHIFT_PR_FRAME     = "max_shift_pr_frame";
  constexpr auto SETUP_KEY_MAX_SIZE               = "max_size";
  constexpr auto SETUP_KEY_MODE                   = "mode";
  constexpr auto SETUP_KEY_NB                     = "nb";
  constexpr auto SETUP_KEY_RATE                   = "rate";
  constexpr auto SETUP_KEY_NOISE                  = "noise";
  constexpr auto SETUP_KEY_PORT                   = "port";
  constexpr auto SETUP_KEY_TIME                   = "time";
  constexpr auto SETUP_KEY_TYPE                   = "type";
  constexpr auto SETUP_KEY_WIN_START_X            = "win_start_x";
  constexpr auto SETUP_KEY_WIN_START_Y            = "win_start_y";
  constexpr auto SETUP_KEY_WIN_WIDTH              = "win_width";
  constexpr auto SETUP_KEY_WIN_HEIGHT             = "win_height";
// @}
 
  // @{
  constexpr auto EXPO_MODE_FINITE                 = "Finite";
  constexpr auto EXPO_MODE_CONTINUOUS             = "Continuous";
  constexpr auto EXPO_MODE_INACTIVE               = "Inactive";
  // @}
 
  // Prefix prepended to Recording Session IDs.
  constexpr auto REC_ID_PREFIX                    = "RecId";
 
  ExpoMode ExpoModeToNb(const std::string& expo_mode);
 
  enum class SimType {
    FILE = 1,
    PATTERN1
  };
 
  // @{
  constexpr auto SIM_TYPE_FILE_STR       = "File";
  constexpr auto SIM_TYPE_PATTERN1_STR   = "Pattern1";
  // @}
 
  // @{
  constexpr auto PUB_STAT_NAME_ACTIVE    = "Active";
  constexpr auto PUB_STAT_NAME_COMPLETED = "Completed";
  constexpr auto PUB_STAT_NAME_STOPPED   = "Stopped";
  constexpr auto PUB_STAT_NAME_ABORTED   = "Aborted";
  constexpr auto PUB_STAT_NAME_FAILED    = "Failed";
  constexpr auto PUB_STAT_NAME_UNDEFINED = "Undefined";
  // @}
 
  std::string RecStatusNameToStr(recif::RecStatusNames rec_status_nb);
 
  std::string PubStatusNameToStr(PubStatus pub_status_nb);
 
  // /// Log level string to number representation.
  // LogLevel LogLevelStrToNb(const std::string& log_level);
 
  std::string BuildKey(const std::vector<std::string>& elements);
 
  std::vector<std::string> SplitKey(const std::string& key);
 
}
 
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())
#define CCFL0C (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;
 
//     /// Constructor registering the location and optional scope description (user defined).
//     /// It generate the scope entering log entry.
//     CCF_TRACE_CLASS(log4cplus::Logger& logger,
//                     const std::string& location,
//                     const std::string& scope = "") {
//       if (s_nesting_level == -2) {
//         s_nesting_level = -1;
//       }
//       s_nesting_level++;
//       m_time_at_scope_entry = core::utils::time::Time();
//       m_location = location;
//       m_scope = scope;
//       m_id = core::utils::base::GenUniqueId();
//       m_logger = &logger;
//       if (scope != "") {
//         LOG4CPLUS_TRACE(logger, (s_padding_chars.substr(0, s_nesting_level) + "ENTERING:" +
//                         m_id + ": " + location + ":" + scope));
//       } else {
//         LOG4CPLUS_TRACE(logger, (s_padding_chars.substr(0, s_nesting_level) + "ENTERING:" +
//                         m_id + ": " + location));
//       }
//     };
 
//     /// Destructor generating the scope exit trace log.
//     ~CCF_TRACE_CLASS() {
//       if (m_scope != "") {
//         LOG4CPLUS_TRACE(*m_logger, (s_padding_chars.substr(0, s_nesting_level) + "LEAVING:" +
//                         m_id + ": " + m_location + ":" + m_scope + " (" + 
//                         core::utils::conversion::NbToStr((core::utils::time::Time() - 
//                         m_time_at_scope_entry), "%.6E") + " s)"));
//       } else {
//         LOG4CPLUS_TRACE(*m_logger, (s_padding_chars.substr(0, s_nesting_level) + "LEAVING:" +
//                         m_id + ": " + m_location + " (" + 
//                         core::utils::conversion::NbToStr((core::utils::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;
//     log4cplus::Logger* m_logger;
// };
 
inline void CcfDebug(const std::string& location,
                     const std::string& msg) {
    fprintf(stdout, "%s:%s#> %s\n", core::utils::time::IsoTimeNow().c_str(), location.c_str(), msg.c_str());
    fflush(stdout);
}
 
#define INFO_LOG_GUARD if (ccf::Base::GetLogLevel() >= ccf::LogLevel::INFO)
 
#define DEBUG_LOG_GUARD if (ccf::Base::GetLogLevel() >= ccf::LogLevel::DEBUG)
 
#define DEBUG2_LOG_GUARD if (ccf::Base::GetLogLevel() >= ccf::LogLevel::DEBUG2)
 
#define DEBUG3_LOG_GUARD if (ccf::Base::GetLogLevel() >= ccf::LogLevel::DEBUG3)
 
#define TRACE_LOG_GUARD if (ccf::Base::GetLogLevel() >= ccf::LogLevel::TRACE)
 
#define CCFERROR(logger, msg) LOG4CPLUS_ERROR(logger, CCFLOC << ": " << msg)
 
#define CCFWARNING(logger, msg) LOG4CPLUS_WARN(logger, CCFLOC << ": " << msg)
 
#define CCFINFO(logger, msg) INFO_LOG_GUARD { LOG4CPLUS_INFO(logger, CCFLOC << ": " << msg); }
 
#define CCFDEBUG(logger, msg) DEBUG_LOG_GUARD { LOG4CPLUS_DEBUG(logger, CCFLOC << ": " << msg); }
 
#define CCFDEBUG2(logger, msg) DEBUG2_LOG_GUARD { LOG4CPLUS_DEBUG(logger, CCFLOC << ": " << msg); }
 
#define CCFDEBUG3(logger, msg) DEBUG3_LOG_GUARD { LOG4CPLUS_DEBUG(logger, CCFLOC << ": " << msg); }
 
// /// TRACE log macro. Includes the location ("CCFLOC") in the log message.
//#define C CFTRACE(logger) TRACE_LOG_GUARD { LOG4CPLUS_TRACE_METHOD(logger __PRETTY_FUNCTION__); }
 
#define CCFTHROW(msg) throw rad::Exception(CCFLOC + ": " + msg)
 
#endif // CCF_COMMON_BASE_HPP_H_