commandsImpl.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020-2025 European Southern Observatory (ESO)
//
// SPDX-License-Identifier: LGPL-3.0-only

#ifndef HLCC_TELIF_TELIF_COMMANDSIMPL_HPP
#define HLCC_TELIF_TELIF_COMMANDSIMPL_HPP
 
#include <Stdif.hpp>
 
#include <rad/exceptions.hpp>
#include <rad/smAdapter.hpp>
 
#include "telif/commands.rad.hpp"
#include "telif/logger.hpp"
 
 
namespace hlcc::telif {
 
class CommandsImpl : public ccsinsif::AsyncCommands {
public:
    explicit CommandsImpl(rad::SMAdapter& sm) : m_sm(sm) {
        /* GCH
         * I do the registration of the RejectionHandler
         * in the definition of each command handler method
         * by adding the line:
         *    m_sm.RegisterDefaultRequestRejectHandler<StdCmds::Exit>();
         * This has the advantage of putting the registration one by one
         * together with the code of each handler, making it easy to keep the
         * code aligned and to handle special cases, for example with
         * specific handlers for commands returning something different form
         * a string or not setting an handler for commands that are always available,
         * in any state and will never be rejected.
         * The drawback is a small performance penalty, since it will try to
         * insert the registration in the std::map every time.
         * Nothing will happen, since std::map will not insert a duplicate and will
         * simply ignore the additional insertion.
         * If that is a problem, we might do the registration here in the constructor,
         * but it will be error prone when keeping the code aligned when
         * adding or removing commands
         */
        RAD_TRACE(GetLogger());
    }
 
    virtual ~CommandsImpl() {
        RAD_TRACE(GetLogger());
    }
 
    virtual elt::mal::future<std::string> Preset(const std::shared_ptr<ccsinsif::PresetArgs>& preset_args) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_INFO_FMT(GetLogger(), "Preset command received with PresetData - Ra  %1.15f, "
        "Dec  %1.15f, Epoch  %s, Parallax  %1.15f, Object_name  %s, "
        "Proper_motion_ra  %1.15f, Proper_motion_dec  %1.15f, Radvel  %1.15f, "
        "Rshift  %1.15f, Velocity_offset_ra  %1.15f, "
        "Velocity_offset_dec  %1.15f, Time_ephem_utc %1.15f", 
        preset_args->getPreset_data()->getTarget_data()->getRa(), preset_args->getPreset_data()->getTarget_data()->getDec(), 
        preset_args->getPreset_data()->getTarget_data()->getEpoch().c_str(),
        preset_args->getPreset_data()->getTarget_data()->getParallax(), preset_args->getPreset_data()->getTarget_data()->getObject_name().c_str(),
        preset_args->getPreset_data()->getTarget_data()->getProper_motion_ra(),
        preset_args->getPreset_data()->getTarget_data()->getProper_motion_dec(),
        preset_args->getPreset_data()->getTarget_data()->getRadvel(), preset_args->getPreset_data()->getTarget_data()->getRshift(),
        preset_args->getPreset_data()->getTarget_data()->getVelocity_offset_ra(),
        preset_args->getPreset_data()->getTarget_data()->getVelocity_offset_dec(), 
        preset_args->getPreset_data()->getTarget_data()->getTime_ephem_utc());
 
        auto ev = std::make_shared<TelifCommands::Preset>(preset_args->clone());
        RAD_TRACE(GetLogger());
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::Preset>();
        m_sm.PostEvent(ev);
        RAD_TRACE(GetLogger());
        return ev->GetPayload().GetReplyFuture();
 
    }
 
    virtual elt::mal::future<std::string> UpdateTarget(const std::string& preset_args) override {
        RAD_TRACE(GetLogger());
 
        auto ev = std::make_shared<TelifCommands::UpdateTarget>(preset_args);
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::UpdateTarget>();
        m_sm.PostEvent(ev);
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> RequestControl(ccsinsif::ControlMode control_mode) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received RequestControl with: Control_mode  " << control_mode);
        auto ev = std::make_shared<TelifCommands::RequestControl>(control_mode);
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::RequestControl>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> ReleaseControl() override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received ReleaseControl");
        auto ev = std::make_shared<TelifCommands::ReleaseControl>();
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::ReleaseControl>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> GetConfig() override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received GetConfig");
 
        auto ev = std::make_shared<EventsApp::GetConfig>("");
        m_sm.RegisterDefaultRequestRejectHandler<EventsApp::GetConfig>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    [[deprecated("SetObservingWavelength is Deprecated - Use UpdateTarget")]]
    virtual elt::mal::future<std::string> SetObservingWavelength(double wavelength) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetObservingWavelength with: Wavelength  " << wavelength);
 
        auto ev = std::make_shared<TelifCommands::SetObservingWavelength>(wavelength);
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::SetObservingWavelength>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetVelocityOffset(const std::shared_ptr<ccsinsif::VelocityOffset>& offset) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetVelocityOffset with: Ra  " << offset->getRa()
                                    << ", Dec  " << offset->getDec());
 
        auto ev = std::make_shared<TelifCommands::SetVelocityOffset>(offset->clone());
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::SetVelocityOffset>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SkyOffset(const std::shared_ptr<ccsinsif::OffsetSkyArgs>& offset_args) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SkyOffset with: Ra  " <<  offset_args->getRa()
                                    << ", Dec  " << offset_args->getDec() << ", Field_stabilization  "
                                    << offset_args->getField_stabilization()
                                    << ", Guide_star_param " << offset_args->getGuide_star_param());
        auto ev = std::make_shared<TelifCommands::SkyOffset>(offset_args->clone());
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::SkyOffset>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> OffsetSetFocalPlane(const std::shared_ptr<ccsinsif::OffsetFocalPlaneArgs>& offset_args) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received OffsetSetFocalPlane with: X  " <<  offset_args->getX()
                                    << ", Y  " << offset_args->getY() << ", Field_stabilization  "
                                    << offset_args->getField_stabilization()
                                    << ", Guide_star_param " << offset_args->getGuide_star_param());
        auto ev = std::make_shared<TelifCommands::OffsetSetFocalPlane>(offset_args->clone());
 
        //m_sm.PostEvent(ev);
        stdif::ExceptionErr icd_ex {"NOT IMPLEMENTED", 0};
        ev->GetPayload().SetException(icd_ex);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetReferenceFocus(double offset) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetReferenceFocus with: Offset  " << offset);
 
        auto ev = std::make_shared<TelifCommands::SetReferenceFocus>(offset);
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::SetReferenceFocus>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetReferenceAberration(const elt::mal::shared_vector<const double>& aberration_offset) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetReferenceAberration with: Aberration_offset  " << aberration_offset);
 
        /* Create a copy obj for the aberration_offset
         * which in this case still have the same shared pointer of the original*/
        elt::mal::shared_vector<const double> aberration_offset_temp(aberration_offset);
 
        /* Make the copy obj unique by reseting the shared pointer reference to a new obj
         * Its equivalent to the Clone() method of other types */
        aberration_offset_temp.make_unique();
 
        auto ev = std::make_shared<TelifCommands::SetReferenceAberration>(aberration_offset_temp);
 
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::SetReferenceAberration>();
 
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> RousConfig(ccsinsif::RousMode mode) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received RousConfig with: Mode  " << mode);
 
        auto ev = std::make_shared<TelifCommands::RousConfig>(mode);
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::RousConfig>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> RousExecute() override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received RousExecute");
 
        auto ev = std::make_shared<TelifCommands::RousExecute>();
        m_sm.RegisterDefaultRequestRejectHandler<TelifCommands::RousExecute>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
private:
    rad::SMAdapter& m_sm;
};
 
}  // namespace hlcc::telif
 
#endif  // HLCC_TELIF_TELIF_COMMANDSIMPL_HPP