device.hpp

Go to the documentation of this file.

#ifndef DEVMGR_COMMON_DEVICE_HPP
#define DEVMGR_COMMON_DEVICE_HPP

#include <fcf/common/dispatcher.hpp>
#include <devmgr/modif/requests.pb.h>
#include <devmgr/common/deviceConfig.hpp>
#include <devmgr/common/deviceLcsIf.hpp>
#include <devmgr/common/iDevice.hpp>
#include <devmgr/common/dataContext.hpp>


namespace devmgr {
  namespace common {

    class DeviceConfig;
    class DeviceLcsIf;
    class Device : public IDevice {

    public:
      Device(const std::string filename,
             const std::string name,
             DataContext& data_ctx);

      virtual ~Device();

      virtual void RegisterComm(std::shared_ptr<fcf::common::IComm> comm_if,
                                fcf::common::Dispatcher<>& failure,
                                fcf::common::Dispatcher<>& normal) = 0;


      virtual bool IsNotReady() const;
      virtual bool IsReady() const;

      virtual bool IsOperational() const;

      virtual void CheckHwFailure() const;

      virtual bool IsDisabling() const;

      virtual void Init();

      virtual void Enable();

      virtual void Disable();

      virtual void Stop();
      
      virtual void Reset();

      virtual void HwReset(modif::ReqHwReset& hwResetMsg);

      virtual void HwInit(modif::ReqHwInit& hwInitMsg);

      virtual void HwEnable(modif::ReqHwEnable& hwEnableMsg);

      virtual void HwDisable(modif::ReqHwDisable& hwDisableMsg);

      virtual void UpdateStatus() = 0;

      virtual void Setup(const modif::ReqSetup& setupMsg) = 0;

      virtual bool IsSetupActive(const modif::ReqSetup& setupMsg) const = 0;

      virtual void Status(const modif::ReqStatus& statusMsg, std::string& buffer) = 0;

      virtual void Status(bool end_acq,
                          const dit::did::Did& dictionary,
                          CCfits::FITS* fits_handle = nullptr) = 0;

      virtual void Simulate(const modif::ReqSimulate& msg);

      virtual void StopSim(const modif::ReqStopSim& msg);

      virtual void Ignore(const modif::ReqIgnore& msg);

      virtual void StopIgn(const modif::ReqStopIgn& msg);

      virtual std::shared_ptr<DeviceLcsIf> GetLcsIf() const = 0;

      virtual std::shared_ptr<IDeviceConfig> GetConfig() const = 0;

      virtual void StartMonitoring();

      virtual void StopMonitoring();

      virtual std::string GetName() const;


    protected:

      bool IsMsgForMe(const std::string& id) const;

      void UpdateDb(std::vector<std::string> attr_vector);

      void SetIgnore(bool flag);

      void SetSimulation(bool flag);

      void GetPrefix(const std::vector<std::string> prefix_list, std::string& prefix);

    protected:
      std::string                    m_filename; 
      std::string                    m_name;     
      DataContext&                   m_data_ctx; 

      // Dispatcher for managing failures.
      fcf::common::Dispatcher<>   m_failure;
      // Dispatcher for managing positive events.
      fcf::common::Dispatcher<>   m_normal;

      // Pointer to configuration object
      std::shared_ptr<DeviceConfig>  m_config;

      // Local Control System Interface
      std::shared_ptr<DeviceLcsIf>   m_lcs_if;

    };
  }
}


#endif //DEVMGR_COMMON_DEVICE_HPP