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>

// 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;

        short  m_state;

        short  m_substate;

        bool m_config_loaded;

        bool m_connected;

        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