sensorLcsIf.hpp

Go to the documentation of this file.

#ifndef DEVMGR_DEVICE_SENSOR_LCSIF_HPP
#define DEVMGR_DEVICE_SENSOR_LCSIF_HPP

// System headers
#include <unordered_map>

// Third party headers
#include <yaml-cpp/yaml.h>

#include <devmgr/common/deviceLcsIf.hpp>
#include <devmgr/devices/sensorConfig.hpp>
#include <devmgr/common/dataContext.hpp>

namespace devmgr {
  namespace sensor {

    struct ChannelData {
      ChannelData();
      virtual ~ChannelData();


      void GetValue(bool& value) const;
      void GetValue(double& value) const;
      void GetValue(int& value) const;


      void SetValue(const fcf::common::Variant value);
      friend std::ostream& operator<<(std::ostream& dest, const ChannelData& obj);

    protected:

      fcf::common::Variant m_value;
    };

    class SensorLcsIf;

    struct SensorControllerData : devmgr::common::DeviceControllerData {
    public:
      SensorControllerData();
      virtual ~SensorControllerData();

      inline std::string GetErrorText() const;

      inline void ClearChannelValues();
      inline void SetChannelValue(std::string channel,
                                  fcf::common::Variant value);
      inline void GetChannelValue(std::string channel,
                                  ChannelData& data);


      void SetData(const SensorControllerData& data);

      friend class SensorLcsIf;
    protected:
      std::unordered_map<std::string, ChannelData> m_values;
    };


    class SensorLcsIf : public devmgr::common::DeviceLcsIf
    {
      // enumerations for the Sensor status

      enum {
        STAT_LOCAL       = 1,
        STAT_ERROR       = 2,
        STAT_STATE       = 3,
        STAT_SUBSTATE    = 4,
        STAT_CHANNEL     = 5,
      };

    public:
       SensorLcsIf(std::shared_ptr<devmgr::common::IDeviceConfig> config,
                         devmgr::common::DataContext& data_ctx);

      virtual bool IsReady();

      virtual bool IsOperational() ;

      void ReadConfig();

     
      bool IsHwFailure();

      virtual void ReadStatus(SensorControllerData& status);

      void StartMonitoring();

      void StopMonitoring();

      void Listener(fcf::common::VectorVariant& params);

      virtual std::string GetRpcError(const short error_code) const;

      virtual std::string GetHwError(int& error_code, const bool update = false);

    private:

      void PublishState(const fcf::common::Variant& value);

      void PublishSubstate(const fcf::common::Variant& value);

      void PublishChannel(const std::string channel,
                          const fcf::common::Variant& value);


    protected:
      std::unordered_map<std::string, short> m_status_map;

      std::vector<std::string> m_monitor_vector;

      std::unordered_map<std::string, std::string> m_channels_map;

    private:
       devmgr::common::DataContext&      m_data_ctx; 
       static std::timed_mutex           m_mutex; 


    };
  }
}

#include "sensorLcsIf.inline"

#endif //DEVMGR_DEVICE_SENSOR_LCSIF_HPP