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
 
#include <yaml-cpp/yaml.h>
 
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include <mal/Cii.hpp>
#include <mal/utility/LoadMal.hpp>
 
#include <ifw/core/utils/bat/logger.hpp>
 
#include <ifw/fnd/defs/iCommAdapter.hpp>
 
#include <eso/uatools/ualib/client.hpp>
 
#include <ifw/fcf/devmgr/common/deviceConfig.hpp>
 
#include <config-ng/ciiConfigApi.hpp>
 
 
namespace ifw::fcf::devmgr::common {
 
// CreateVariantVector(...) was removed during the port to
// ICommAdapter. Use `MakeCallArgs(...)` from
// `ifw/fcf/devmgr/common/fcfCommHelpers.hpp` instead — same idea,
// returns std::vector<ifw::fnd::defs::CallArgument> ready for
// `ualib::Client::Call`.

  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);
 
  private:
    int    m_state;
    int    m_substate;
    bool   m_local;
    int    m_error_code;
  };

  class DataContext;
 
  // cppcheck-suppress unusedStructMember
  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<ifw::fnd::defs::ICommAdapter> comm_if,
                              std::function<void()> on_failure,
                              std::function<void()> on_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(const ifw::fnd::defs::Notification& note);

    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;

    ifw::fnd::defs::SubscriptionHandler GetSubscriptionHandler();

    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,
                    std::vector<ifw::fnd::defs::CallArgument> args);

    static std::pair<std::string, std::string>
    DecodeRpcAddress(const std::string& proc,
                     const std::string& obj_hint = "");
    int ReadErrorCode();
 
 

    void StoreUaNames(const std::vector <std::pair<std::string, unsigned int>>& ualist);

    void StoreAttribute(const std::string& key,
                        const ifw::fnd::defs::Value& value,
                        int  attribute);
 
    inline void SetConfigLoad(bool flag);
 
    protected:
 
    // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
    std::shared_ptr<IDeviceConfig>  m_config;
    std::unique_ptr<elt::configng::CiiConfigDocument> m_config_doc;
 
 

    std::string m_lcs_prefix;

    std::shared_ptr<ifw::fnd::defs::ICommAdapter>  m_comm;

    std::function<void()>   m_on_failure;

    std::function<void()>   m_on_normal;

    ifw::fnd::defs::RegistrationToken  m_state_token;

    int  m_state {};

    int  m_substate {};

    bool  m_local {false};

    int  m_error_code {false};

    bool m_config_loaded {false};

    bool m_connected {false};
 
    ifw::fcf::devmgr::common::DataContext&      m_data_ctx;

    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;
    // NOLINTEND(misc-non-private-member-variables-in-classes)
 
  private:
    log4cplus::Logger              m_logger;
 
  };
 
} //namespace
 
#include "deviceLcsIf.ipp"
 
#endif // FCF_DEVMGR_COMMON_DEVICE_LCS_IF_H