recipeBase.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_RECIPE_BASE_HPP_H_
#define CCF_COMMON_RECIPE_BASE_HPP_H_
 
#include <ccf/common/base.hpp>
#include <ccf/common/setupBase.hpp>
#include <ccf/common/dataFrame.hpp>
 
#include <cpl.h>
#include <clipm.h>
 
namespace ccf::common {
 
  // @{
  const std::string SETUP_KEY_RECIPE_ENABLED    = "proc%d.recipe%d.enabled";
  const std::string SETUP_KEY_RECIPE_BASE_DELAY = "proc%d.recipe%d.recipe_base.delay";
  // @}
 
  template <class SRC_IM_TYPE, class TRG_IM_TYPE>
  void ConvertImage(SRC_IM_TYPE* image_buffer,
                    uint32_t pixels,
                    TRG_IM_TYPE** target_buf,
                    uint32_t* target_buf_size) {
    CCFTRACE;
    *target_buf_size = (pixels * sizeof(TRG_IM_TYPE));
    *target_buf = (TRG_IM_TYPE*)malloc(*target_buf_size);
    ccf::common::AssertPtr(target_buf, "CPL Image Tmp Buffer", CCFLOC);
    SRC_IM_TYPE* im_ptr = image_buffer;
    TRG_IM_TYPE* target_buf_ptr = *target_buf;
    for (uint32_t n = 0; n < pixels; n++) {
      *target_buf_ptr++ = static_cast<TRG_IM_TYPE>(*im_ptr++);
      }
  }
 
  void PrepCplImage(const ccf::common::DataFrame& frame,
                    cpl_image** image,
                    ccf::common::ImageDataType* target_data_type,
                    uint32_t* target_buffer_size);
 
 
  class RecipeBase: public Base {
  public:
 
    static const std::string& GenId(const uint16_t proc_thread_nb,
                                    const uint16_t recipe_nb);
 
    static void AddRecipeFactoryObj(RecipeBase& recipe_factory_obj);
 
    static void GetRecipeFactoryObjs(std::vector<RecipeBase*>& recipe_factory_objs);
 
    static void CreateRecipeObj(const std::string& class_name,
                                const uint16_t proc_thread_nb,
                                const uint16_t recipe_nb,
                                const std::string recipe_name,
                                RecipeBase** new_obj);
 
    static void GetRecipeObj(const uint16_t proc_thread_nb,
                             const uint16_t recipe_nb,
                             RecipeBase** recipe_obj,
                             const bool initialise = true);
 
    static void GetRecipeObjs(std::vector<RecipeBase*>& recipe_objs);
 
    static bool HasRecipeObj(const uint16_t proc_thread_nb,
                             const uint16_t recipe_nb,
                             RecipeBase** recipe_obj);
 
    static void FreeRecipeObjs();
 
    static void FreeRecipeFactoryObjs();
 
    RecipeBase(const uint16_t proc_thread_nb,
               const uint16_t recipe_nb,
               const std::string& recipe_name);
 
    RecipeBase();
 
    virtual ~RecipeBase();
 
    void Initialise();
 
    virtual void InitialiseUser();
 
    bool GetInitialised() const;
 
    const std::string& GetRecipeId() const;
 
    const std::string& GetRecipeName() const;
 
    uint16_t GetProcThreadNb() const;
 
    uint16_t GetRecipeNb() const;
 
    const std::string& GetDbPath() const;
 
    const std::string& GetKeyPrefix() const;
 
    const std::string GenKey(const std::string& name) const;
 
    void Process(DataFrame& frame);
 
    // /// Set the enabled status flag of the recipe object.
    // void SetEnabled(const bool enabled);
 
    // /// Disable the recipe so that it will not be invoked.
    // void DisableRecipe();
 
    void Enable();
 
    virtual void EnableUser();
 
    void Disable();
 
    virtual void DisableUser();
 
    bool GetEnabled() const;
 
    virtual void ProcessUser(DataFrame& frame);
 
    virtual void CreateObjectUser(const uint16_t proc_thread_nb,
                                  const uint16_t recipe_nb,
                                  const std::string& recipe_name,
                                  RecipeBase** new_object);
 
    void SetStatus(const ProcStatus status);
 
    ProcStatus GetStatus() const;
 
    // TODO: Consider to add.
    // RecipeBase& SetRecipePar(const ctd::param::Parameter& recipe_par);
    // bool HasRecipePar(const std::string& par_name,
    //                   ctd::param::Parameter** recipe_par);
    // RecipeBase& ClearRecipePars();
 
    // TODO: Add:
    // void ResetDbStatus() const;
    // void UpdateDbStatus() const;
    // std::string ToString() const;
    // void Dismantle();
    // virtual void DismantleUser();
 
    // TODO: Add + invoke when a setup command is received.
    // void HandleSetup();
    // void HandleSetupUser();
 
  protected:
 
    void SetEnabled(const bool enabled);
 
    void DisableRecipe();
 
  private:
    static std::map<std::string, RecipeBase*>  s_recipe_factory_objects;
    static std::map<std::string, RecipeBase*>  s_recipe_objects;
    static bool s_cpl_initialised;
 
    bool          m_initialised;
    bool          m_enabled;
    double        m_delay;
 
    std::string   m_recipe_id;
    std::string   m_recipe_name;
    uint16_t      m_proc_thread_nb;
    uint16_t      m_recipe_nb;
 
    //std::map<std::string, ctd::param::Parameter> m_recipe_pars;
 
    // TODO: Check if m_recipe_properties needed.
    //std::map<std::string, ctd::param::Parameter> m_recipe_properties;
 
    ProcStatus    m_recipe_status;
 
    std::string   m_db_base_name;
    std::string   m_key_prefix;
  };
 
}
 
#endif // CCF_COMMON_RECIPE_BASE_HPP_H_