deviceFacade.hpp

Go to the documentation of this file.

#ifndef FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
#define FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_

// System headers
#include <list>

// Local headers
#include <rad/smAdapter.hpp>
#include <rad/topicPub.hpp>
#include <rad/anyEvent.hpp>
#include <rad/activity.hpp>

#include <fcf/common/dispatcher.hpp>
#include <fcf/devmgr/common/device.hpp>
#include <fcf/devmgr/common/events.rad.hpp>

namespace fcf {
  namespace devmgr {
    namespace common {

      class Config;
      class IDevice;

      class DeviceFacade {
      public:
        DeviceFacade(rad::SMAdapter& sm,
                     IConfig& config,
                     fcf::common::Dispatcher<>& failure,
                     fcf::common::Dispatcher<>& normal);

        virtual     ~DeviceFacade();

        virtual bool Init(rad::SMAdapter& sm, rad::ThreadActivity* activity);

        virtual bool Enable(rad::SMAdapter& sm, rad::ThreadActivity* activity);

        virtual bool Recover(rad::SMAdapter& sm, rad::ThreadActivity* activity);
        virtual bool Disable();

        virtual bool Setup(const std::any& payload, rad::ThreadActivity* activity);
        virtual void Stop();

        virtual void Reset();

        virtual void Status(const std::any& payload, std::string& buffer);


        virtual void Simulate(rad::AnyEvent const& last_event);

        virtual void StopSim(rad::AnyEvent const& last_event);

        virtual void Ignore(rad::AnyEvent const& last_event);

        virtual void StopIgn(rad::AnyEvent const& last_event);

        virtual void HwReset(rad::AnyEvent const& last_event);

        virtual void HwInit(rad::AnyEvent const& last_event);

        virtual void HwEnable(rad::AnyEvent const& last_event);

        virtual void HwDisable(rad::AnyEvent const& last_event);

        virtual std::string DevNames();

        virtual void BeginAcq(rad::AnyEvent const& last_event);

        virtual void EndAcq(rad::AnyEvent const& last_event);


        void    TriggerInternalEvent(rad::SMAdapter& sm, rad::UniqueEvent&& e);

        void    AddDevice(std::shared_ptr<IDevice> device);

        void    ClearDevices();

        fcf::common::Dispatcher<>& GetFailureCB();

        fcf::common::Dispatcher<>& GetNormalCB();

        const int GetNumDevices();

      private:

        DeviceFacade(const DeviceFacade&) = delete;             
        DeviceFacade& operator= (const DeviceFacade&) = delete; 

        void InitSync(rad::ThreadActivity* activity,
                      std::chrono::system_clock::time_point start_time,
                      bool& stopped,
                      bool& timeout);

        void EnableSync(rad::ThreadActivity* activity,
                        std::chrono::system_clock::time_point start_time,
                        bool& stopped,
                        bool& timeout);

        void DeviceFailureCB();

        void DeviceNormalCB();

        void CheckDeviceName(const std::vector<std::string>& devices) const;

        std::vector<std::shared_ptr<IDevice> >  m_devices;   
        std::vector<std::string>  m_device_names;   
        boost::asio::io_service               m_ios;       
        rad::SMAdapter&                       m_sm;        
        IConfig&                              m_config;
        std::string                           m_dp_filename; 

        fcf::common::Dispatcher<>   m_failure;

        fcf::common::Dispatcher<>   m_normal;
      };
    }
  }
}  // namespace devmgr::Common

#endif  // FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_