recipeBase.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_RECIPE_BASE_HPP_H_
#define CCF_COMMON_RECIPE_BASE_HPP_H_
 
#include <cpl.h>
#include <clipm.h>
 
#include <ccf/common/base.hpp>
#include <ccf/common/db.hpp>
#include <ccf/common/setup.hpp>
#include <ccf/common/dataFrame.hpp>
 
 
namespace ccf::common {
 
  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) {
    LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
    *target_buf_size = (pixels * sizeof(TRG_IM_TYPE));
    *target_buf = (TRG_IM_TYPE*)malloc(*target_buf_size);
    ccf::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::DataTypes* target_data_type,
                    uint32_t* target_buffer_size);
 
 
  class RecipeBase: public Base {
  public:
 
    static const std::string& GenId(const std::string& proc_thread_name,
                                    const std::string& recipe_name);
 
    template <class TYPE>
    static void AddRecipeFactoryObj(TYPE& recipe_factory_obj) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      if (recipe_factory_obj.GetClassName() == "") {
        CCFTHROW("Must define a classname for a Processing Recipe Plug-In");
      }
 
      BEGIN_CRIT_SEC("ccf::common::RecipeBase") {
        if (s_recipe_factory_objects.find(recipe_factory_obj.GetClassName()) !=
          s_recipe_factory_objects.end()) {
            CCFTHROW(fmt::format("Factory object with classname: {} already exists",
                                 recipe_factory_obj.GetClassName()));
        }
        CCFINFO(Logger(), "Registering Processing Recipe factory object. Classname: " <<
          recipe_factory_obj.GetClassName());
        s_recipe_factory_objects[recipe_factory_obj.GetClassName()] = std::make_shared<TYPE>();
      } END_CRIT_SEC();
 
  }
 
    static const std::map<std::string, std::shared_ptr<RecipeBase>>& GetRecipeFactoryObjs();
 
    static void CreateRecipeObj(const std::string& class_name,
                                const std::string& proc_thread_name,
                                const std::string& recipe_name,
                                std::shared_ptr<RecipeBase>& new_obj);
 
    static void GetRecipeObj(const std::string& class_name,
                             const std::string& proc_thread_name,
                             std::shared_ptr<RecipeBase>& recipe_obj,
                             const bool initialise = true);
 
    static const std::map<std::string, std::shared_ptr<RecipeBase>>& GetRecipeObjs();
 
    static bool HasRecipeObj(const std::string& class_name,
                             const std::string& proc_thread_name,
                             std::shared_ptr<RecipeBase>& recipe_obj);
 
    // static void FreeRecipeObjs();
 
    // static void FreeRecipeFactoryObjs();
 
    RecipeBase(const std::string& proc_thread_name,
               const std::string& recipe_name);
 
    RecipeBase();
 
    virtual ~RecipeBase();
 
    void Initialise();
 
    virtual void InitialiseUser();
 
    bool GetInitialised() const;
 
    const std::string& GetRecipeId() const;
 
    const std::string& GetProcThreadName() const;
 
    const std::string& GetRecipeName() const;
 
    const std::string& GetDbPath() 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 std::string& proc_thread_name,
                                  const std::string& recipe_name,
                                  std::shared_ptr<RecipeBase>& new_object);
 
    void SetStatus(const ProcStatus status);
 
    ProcStatus GetStatus() const;
 
    // 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, std::shared_ptr<RecipeBase>>  s_recipe_factory_objects;
    static std::map<std::string, std::shared_ptr<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;
    std::string   m_proc_thread_name;
 
    ProcStatus    m_recipe_status;
 
    std::string   m_db_base_name;
  };
 
}
 
#endif // CCF_COMMON_RECIPE_BASE_HPP_H_