subsysFacade.hpp

Go to the documentation of this file.

 
#ifndef SUP_SYSSUP_COMMON_SUBSYS_FACADE_HPP_
#define SUP_SYSSUP_COMMON_SUBSYS_FACADE_HPP_
 
// System headers
#include <iostream>
#include <list>
#include <atomic>
#include <type_traits>
 
// Local headers
#include <rad/smAdapter.hpp>
#include <rad/topicPub.hpp>
#include <rad/anyEvent.hpp>
#include <rad/activity.hpp>
#include <rad/mal/utils.hpp>
 
 
#include <sup/syssup/common/subsys.hpp>
#include <sup/syssup/common/events.rad.hpp>
 
namespace sup {
  namespace syssup {
    namespace common {
 
      template<typename T>
      std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
      {
          return stream << static_cast<typename std::underlying_type<T>::type>(e);
      }
 
      template<typename EVENT_TYPE>
      class SingleReplier {
      public:
        using Request = std::optional<typename EVENT_TYPE::payload_t>;
        using RequestMap   = std::map<std::string, Request>;
        using RequestPair  = std::pair<std::string, Request>;
 
      public:
        void InsertRequest(RequestPair pair);
        void ReplyOk(std::string req_id, std::string msg);
        void ReplyError(std::string req_id, std::string msg);
 
        RequestMap    m_req_map;
      };
 
      class IConfig;
      class ISubsys;
 
      class SubsysFacade {
      public:
        SubsysFacade(rad::SMAdapter& sm,
                     DataContext& data_ctx);
 
        virtual     ~SubsysFacade();
 
        void Connect();
 
        void StartMonitoring();
 
       void Init(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
       void Enable(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
       void Disable(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
       void Recover(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
 
       void   Setup(const std::any& payload);
 
        virtual void Stop();
 
        virtual void Reset();
 
 
        template<typename EVENT_TYPE, typename OBJECT>
        void SubsysCommand(scxml4cpp::Context* c, OBJECT& obj);
 
        void UpdateConfiguration();
 
        void UpdateHandler();
 
        virtual void EstimateState(std::vector<State::StateEnum>& states,
                                   std::vector<State::SubstateEnum>& substates);
 
       void SetSubsystemConnectionState(std::string name,
                                        SubsysData::ConnectionEnum connection);
 
       void SetSubsystemState(std::string name, std::string state);
 
       void SetSubsystemSubstate(std::string name, std::string substate);
 
       void GetSubsystemStatus(const std::string& payload, std::string& buffer);
 
 
        void    AddSubsys(std::unique_ptr<Subsys> subsys);
 
        void    ClearSubsys();
 
 
        const int GetNumSubsys();
 
        std::string GetSubsysNames();
 
      private:
 
        SubsysFacade(const SubsysFacade&) = delete;             
        SubsysFacade& operator= (const SubsysFacade&) = delete; 
 
 
      template <typename Iterator, typename EVENT_DONE, typename EVENT_ERR, typename EVENT_TOUT>
         void ManageReply(Iterator& vec, rad::ThreadActivity* activity,
                          int wait_time_msecs, bool reply_on_success = true);
 
 
       bool CheckSubsysName(const std::string& subsys) const;
 
        std::vector<std::unique_ptr<Subsys> >      m_subsyss;   
        std::vector<std::string>                   m_subsys_names;   
        boost::asio::io_service                    m_ios;       
        rad::SMAdapter&                            m_sm;        
        DataContext&                               m_data_ctx; 
 
      public:
        SingleReplier<Events::SubsysInit> m_init_replier;
        SingleReplier<Events::SubsysEnable> m_enable_replier;
        SingleReplier<Events::SubsysDisable> m_disable_replier;
        SingleReplier<Events::SubsysReset> m_reset_replier;
      };
 
 
    }
  }
}  // namespace devmgr::Common
 
#include "subsysFacade.ipp"
 
#endif  // SUP_SYSSUP_COMMON_SUBSYS_FACADE_HPP_