deviceLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICE_LCS_IF_H
#define FCF_DEVMGR_COMMON_DEVICE_LCS_IF_H
 
// Third party headers
#include <yaml-cpp/yaml.h>
#include <variant>
 
#include <mal/Cii.hpp>
#include <mal/utility/LoadMal.hpp>
 
// Local headers
#include <utils/bat/logger.hpp>
#include <ifw/core/protocol/base/iComm.hpp>
#include <ifw/core/protocol/base/dispatcher.hpp>
#include <fcf/devmgr/common/deviceConfig.hpp>
//#include <rad/mal/publisher.hpp>
 
// New CII Config Service
#include <config-ng/ciiConfigApi.hpp>
 
namespace fcf::devmgr::common {
 
// Variadic template function to create a vector of variants
template<typename... Args>
protocol::base::VectorVariant CreateVariantVector(Args&&... args) {
 
  return {std::make_pair(std::string(),
                           protocol::base::Variant(std::forward<Args>(args)))... };
 
}
 
  struct DeviceControllerData {
  public:
    DeviceControllerData();
    virtual ~DeviceControllerData();
    inline int GetState() const;
    inline void SetState(int state);
    inline int GetSubstate() const;
    inline std::string GetStateStr() const;
    inline void SetSubstate(int subtate);
    inline bool GetLocalFlag() const;
    inline void SetLocalFlag(bool local_flag);
    inline int GetErrorCode() const;
    inline void SetErrorCode(int error_code);
 
    void SetData(const DeviceControllerData& data);
 
  protected:
    int    m_state;
    int    m_substate;
    bool   m_local;
    int    m_error_code;
  };
 
  class DataContext;
 
  class DeviceLcsIf {
  public:
    explicit DeviceLcsIf(std::shared_ptr<IDeviceConfig> config,
                         DataContext& data_ctx);
 
    enum {
      STAT_LOCAL       = 1,
      STAT_ERROR       = 2,
      STAT_HW_STATUS   = 3,
      STAT_STATE       = 4,
      STAT_SUBSTATE    = 5
    };
 
 
    virtual void InitObject();
 
    virtual void RegisterComm(std::shared_ptr<protocol::base::IComm> comm_if,
                              protocol::base::Dispatcher<>& failure,
                              protocol::base::Dispatcher<>& normal);
 
    virtual void Connect();
 
    virtual void Disconnect();
 
    virtual bool IsNotReady() const;
 
    virtual bool IsReady() const;
 
    virtual bool IsDisabling() const;
 
    virtual bool IsOperational() const;
 
    virtual bool IsHwFailure() const;
 
    virtual void Init();
 
    virtual void Enable();
 
    virtual void Disable();
 
    virtual void Stop();
 
    virtual void Reset();
 
    virtual void StartMonitoring();
 
    virtual void StopMonitoring();
 
    virtual void ReadStatus(DeviceControllerData& status);
 
    virtual void Listener(protocol::base::VectorVariant& params);
 
    virtual std::string GetRpcError(const short error_code) const = 0;
 
    virtual std::string GetHwError(int& error_code, const bool update = false);
 
 
    std::string GetMapValue(const std::string& category, const std::string& key) const;
 
    protocol::base::Dispatcher<protocol::base::VectorVariant&>& GetDispatcher();
 
    bool IsConfigLoaded() const;
 
    bool IsConnected() const;
 
    virtual std::shared_ptr<IDeviceConfig> GetDeviceConfig() const;
 
    const elt::configng::CiiConfigInstanceNamespace& GetCfgInstance() const;
 
 
    virtual void GetStates(int &state, int &substate);
 
  protected:
 
    void LoadConfig();
 
    void ExecuteRpc(const std::string& obj,
                    const std::string& proc,
                    protocol::base::VectorVariant& attr_list);
    int ReadErrorCode();
 
 
 
    void StoreUaNames(const std::vector <std::pair<std::string, unsigned int>>& ualist);
 
    void StoreAttribute(const std::string key,
                        const protocol::base::Variant& value,
                        int  attribute);
    std::unique_ptr<elt::configng::CiiConfigDocument> m_config_doc;
 
    std::shared_ptr<protocol::base::IComm>  m_comm;
 
    std::shared_ptr<IDeviceConfig>  m_config;
 
    protocol::base::Dispatcher<protocol::base::VectorVariant&>  m_dispatcher;
 
    protocol::base::Dispatcher<>   m_failure;
 
    protocol::base::Dispatcher<>   m_normal;
 
    int  m_state {};
 
    int  m_substate {};
 
    bool  m_local {false};
 
    bool  m_error_code {false};
 
    bool m_config_loaded {false};
 
    bool m_connected {false};
 
    fcf::devmgr::common::DataContext&      m_data_ctx;
 
    std::string m_lcs_prefix;
 
 
    std::unordered_map<std::string, short> m_ua_status_map;
 
    std::vector<std::string> m_ua_monitor_vector;
 
    std::unordered_map<short, std::string> m_hw_errors;
 
  private:
    log4cplus::Logger              m_logger;
 
  };
 
} //namespace
 
#include "deviceLcsIf.ipp"
 
#endif // FCF_DEVMGR_COMMON_DEVICE_LCS_IF_H