appCmdsImpl.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_APP_CMDS_IMPL_HPP_
#define FCF_DEVMGR_COMMON_APP_CMDS_IMPL_HPP_
 
#include "ifw/fcf/devmgr/common/events.rad.hpp"
 
#include <ifw/core/utils/bat/logger.hpp>
#include <rad/exceptions.hpp>
#include <rad/smAdapter.hpp>
 
namespace ifw::fcf::devmgr::common {
 
class AppCmdsImpl : public fcfif::AsyncAppCmds {
public:
    AppCmdsImpl(rad::SMAdapter& sm) : mSM(sm), m_logger(ifw::core::utils::bat::GetAppLogger()) {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
    }
 
    virtual ~AppCmdsImpl() {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
    }
 
    virtual elt::mal::future<std::string> DevStatus(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::DevStatus* ev = new Events::DevStatus(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Config() override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Config* ev = new Events::Config();
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> GetConfig() override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
 
        Events::GetConfig* ev = new Events::GetConfig();
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Simulate(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Simulate* ev = new Events::Simulate(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StopSim(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StopSim* ev = new Events::StopSim(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Ignore(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Ignore* ev = new Events::Ignore(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StopIgn(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StopIgn* ev = new Events::StopIgn(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> HwInit(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::HwInit* ev = new Events::HwInit(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> HwEnable(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::HwEnable* ev = new Events::HwEnable(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> HwDisable(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::HwDisable* ev = new Events::HwDisable(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> HwReset(const std::vector<std::string>& devices) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::HwReset* ev = new Events::HwReset(devices);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Setup(const std::vector<std::shared_ptr<fcfif::SetupElem>>& buffer) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Setup* ev = new Events::Setup(buffer);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Recover() override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Recover* ev = new Events::Recover();
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> DevNames() override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::DevNames* ev = new Events::DevNames();
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
 
    virtual elt::mal::future<std::string> DevInfo() override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::DevInfo* ev = new Events::DevInfo();
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> DevConfig(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::DevConfig* ev = new Events::DevConfig(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Open(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Open* ev = new Events::Open(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> Close(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::Close* ev = new Events::Close(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> OpenAt(const std::shared_ptr<fcfif::OpenAtParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::OpenAt* ev = new Events::OpenAt(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SwitchOn(const std::shared_ptr<fcfif::SwitchOnParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::SwitchOn* ev = new Events::SwitchOn(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SwitchOff(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::SwitchOff* ev = new Events::SwitchOff(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> MoveAbs(const std::shared_ptr<fcfif::MoveAbsParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::MoveAbs* ev = new Events::MoveAbs(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> MoveAxes(const std::shared_ptr<fcfif::MoveAxesParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::MoveAxes* ev = new Events::MoveAxes(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> MoveByName(const std::shared_ptr<fcfif::MoveByNameParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::MoveByName* ev = new Events::MoveByName(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> MoveByPosUser(const std::shared_ptr<fcfif::MoveAbsParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::MoveByPosUser* ev = new Events::MoveByPosUser(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StartTrack(const std::shared_ptr<fcfif::StartTrackParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StartTrack* ev = new Events::StartTrack(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StopTrack(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StopTrack* ev = new Events::StopTrack(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> TrackOffset(const std::shared_ptr<fcfif::TrackOffsetParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::TrackOffset* ev = new Events::TrackOffset(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetTipTilt(const std::shared_ptr<fcfif::SetTipTiltParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::SetTipTilt* ev = new Events::SetTipTilt(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StartCtrl(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StartCtrl* ev = new Events::StartCtrl(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> StopCtrl(const std::string& devname) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::StopCtrl* ev = new Events::StopCtrl(devname);
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetTrajectory(const std::shared_ptr<fcfif::SetTrajectoryParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::SetTrajectory* ev = new Events::SetTrajectory(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetCustom(const std::shared_ptr<fcfif::SetCustomParams>& params) override {
        LOG4CPLUS_TRACE_METHOD(m_logger,__PRETTY_FUNCTION__);
        Events::SetCustom* ev = new Events::SetCustom(params->clone());
        mSM.PostEvent(rad::UniqueEvent(ev));
        return ev->GetPayload().GetReplyFuture();
    }
 
private:
    rad::SMAdapter& mSM;
    log4cplus::Logger m_logger;
};
 
}  // namespace server
 
#endif  // FCF_DEVMGR_COMMON_APP_CMDS_IMPL_HPP_