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 <mal/Cii.hpp>
#include <mal/utility/LoadMal.hpp>
 
// Local headers
#include <fcf/common/iComm.hpp>
#include <fcf/common/dispatcher.hpp>
#include <fcf/devmgr/common/deviceConfig.hpp>
//#include <rad/mal/publisher.hpp>
 
namespace fcf {
  namespace devmgr {
    namespace common {
 
      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 RegisterComm(std::shared_ptr<fcf::common::IComm> comm_if,
                                  fcf::common::Dispatcher<>& failure,
                                  fcf::common::Dispatcher<>& normal);
 
        virtual void Connect();
 
        virtual void Disconnect();
 
        virtual void ReadConfig(const std::vector<std::string>& stat_map_vector,
                                const std::vector<std::string>& rpc_map_vector);
 
 
        virtual bool IsNotReady();
 
        virtual bool IsReady();
 
        virtual bool IsDisabling();
 
        virtual bool IsOperational();
 
        virtual bool IsHwFailure();
 
        virtual void Init();
 
        virtual void Enable();
 
        virtual void Disable();
 
        virtual void Stop();
 
        virtual void Reset();
 
        virtual void StartMonitoring();
 
        virtual void StopMonitoring();
 
        virtual void Listener(fcf::common::VectorVariant& params) = 0;
 
        virtual std::string GetRpcError(const short error_code) const = 0;
 
        virtual std::string GetHwError(int& error_code, const bool update = false);
 
 
        std::string GetMapValue(std::string category, std::string key);
 
        fcf::common::Dispatcher<fcf::common::VectorVariant&>& GetDispatcher();
 
        bool IsConfigLoaded() const;
 
        bool IsConnected() const;
 
        virtual std::shared_ptr<IDeviceConfig> GetDeviceConfig();
 
 
      protected:
 
        void LoadConfig();
 
        void ExecuteRpc(const std::string& obj,
                        const std::string& proc,
                        fcf::common::VectorVariant& attr_list);
        int ReadErrorCode();
 
        void GetStates(int &state, int &substate);
 
        void StoreUaNames(const std::vector <std::pair<std::string, unsigned int>>& ualist);
 
        void StoreAttribute(const std::string key,
                            const fcf::common::Variant& value,
                            int  attribute);
        YAML::Node  m_config_node;
 
        std::shared_ptr<fcf::common::IComm>  m_comm;
 
        std::shared_ptr<IDeviceConfig>  m_config;
 
        fcf::common::Dispatcher<fcf::common::VectorVariant&>  m_dispatcher;
 
        fcf::common::Dispatcher<>   m_failure;
 
        fcf::common::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;
 
        elt::mal::Mal::Properties m_mal_properties;
        std::string m_pub_endpoint;
 
 
        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;
 
 
      };
    }
  }
}
 
#include "deviceLcsIf.ipp"
 
#endif // FCF_DEVMGR_COMMON_DEVICE_LCS_IF_H