base.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_BASE_HPP_H_
#define CCF_COMMON_BASE_HPP_H_
 
#include <execinfo.h>
#include <iostream>
#include <cstdlib>
#include <cxxabi.h>
#include <fmt/format.h>
 
#include <boost/exception/diagnostic_information.hpp>
 
#include <config-ng/ciiConfigApi.hpp>
 
#include <Recif.hpp>
 
#include <ifw/fnd/defs/dataType.hpp>
 
#include <ifw/core/utils/base/base.hpp>
#include <ifw/core/utils/system/system.hpp>
#include <ifw/core/utils/time/time.hpp>
#include <ifw/core/utils/conversion/conversion.hpp>
#include <ifw/core/utils/bat/config.hpp>
 
#include <ifw/ccf/mptk/manager.hpp>
 
 
namespace ifw::ccf {
 
  extern std::string ccf_application_name;
 
  void SetApplicationLogName(const std::string& app_name);
 
  log4cplus::Logger& Logger();
  log4cplus::Logger& FastLogger();

  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(ifw::core::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");
  // @}
 
  void PrintStackTrace();

  ifw::fnd::datatype::DataType CiiCfgNodeToIfwDataType(elt::configng::CiiConfigInstanceNode& node);
 
  // }

  // @{
  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_name,
                  const std::string& receiver_thread_name,
                  const std::string& data);

  bool ReceiveThrMsg(const std::string& receiver_thread_name,
                     const double time_out,
                     ifw::ccf::mptk::Message& message);

  void DecomposeSmStatus(const std::string& sm_state,
                         std::string& sum_state,
                         std::string& sum_substate);

  class Base {
  public:

    static ifw::ccf::mptk::Manager& Mptk() {
        return s_mptk_mgr;
    }
 
 
    Base();
    ~Base();

    const std::string& GetClassName() const;
 
  protected:
    void SetClassName(const std::string& class_name);
 
  private:
    static ifw::ccf::mptk::Manager     s_mptk_mgr;
    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(ifw::ccf::Status status);

  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_TELEMETRY               = "telemetry";
  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_AUTO_ADJUST_TIME_RATE    = "auto_adjust_time_rate";
  constexpr auto CFG_KEY_ALLOW_FRAME_SKIPPING     = "allow_frame_skipping";
  constexpr auto CFG_KEY_ALLOW_LOST_FRAMES        = "allow_lost_frames";
  constexpr auto CFG_KEY_AUTO_STOP_ACQ_AFTER_REC  = "auto_stop_acq_after_rec";
  constexpr auto CFG_KEY_ENABLED                  = "enabled";
  constexpr auto CFG_KEY_DATA_TYPE                = "data_type";
  constexpr auto CFG_KEY_DEVICES                  = "devices";
  constexpr auto CFG_KEY_HEIGHT                   = "height";
  constexpr auto CFG_KEY_ID                       = "id";
  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_METADATA_KEY             = "metadata_key";
  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_OLDB_NODE                = "oldb_node"; 
  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 CFG_KEY_WRITE_ON_INIT            = "write_on_init";
  // @}

  // @{
  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_INTERFACE              = "interface";
  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,
    GAUSSIAN,
    MULTI_GAUSSIAN,
    FLAT,
    GRID,
    GRADIENT,
    RING,
    CHECKERBOARD,
    NOISE,
    GRATING
  };

  enum class GradientDir {
    HORIZONTAL = 1,
    VERTICAL,
    RADIAL
  };

  enum class NoiseDist {
    GAUSSIAN = 1,
    POISSON,
    UNIFORM
  };

  // @{
  constexpr auto SIM_TYPE_FILE_STR           = "File";
  constexpr auto SIM_TYPE_GAUSSIAN_STR       = "Gaussian";
  constexpr auto SIM_TYPE_MULTI_GAUSSIAN_STR = "MultiGaussian";
  constexpr auto SIM_TYPE_FLAT_STR           = "Flat";
  constexpr auto SIM_TYPE_GRID_STR           = "Grid";
  constexpr auto SIM_TYPE_GRADIENT_STR       = "Gradient";
  constexpr auto SIM_TYPE_RING_STR           = "Ring";
  constexpr auto SIM_TYPE_CHECKERBOARD_STR   = "Checkerboard";
  constexpr auto SIM_TYPE_NOISE_STR          = "Noise";
  constexpr auto SIM_TYPE_GRATING_STR        = "Grating";
  // @}

  // @{
  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);

  std::string BuildKey(const std::vector<std::string>& elements);

  std::vector<std::string> SplitKey(const std::string& key);
 
}
 
#define CCFTIME ifw::core::utils::time::Time()

// inline void CcfDebug(const std::string& location,
//                      const std::string& msg) {
//     fmt::print("{}:{}#> {}\n", ifw::core::utils::time::IsoTimeNow(), location, msg);
//     std::fflush(stdout);
// }
 
 
#define CCFDEBUG(msg) \
    do { \
        fmt::print(stdout, "CCF-DEBUG#####>>>>> {}: {}\n", IFWLOC, msg); \
        std::fflush(stdout); \
    } while (0)
 

#define CCFTHROW(msg) throw rad::Exception(IFWLOC + ": " + msg)
 
#endif // CCF_COMMON_BASE_HPP_H_