offsetHandler.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_OFFSETHANDLER_HPP
#define HLCC_TELIF_TELIF_OFFSETHANDLER_HPP
 
#include <mutex>
 
#include <boost/asio/thread_pool.hpp>
#include <gtest/gtest_prod.h>
#include "Ccsinsif.hpp"
#include "Telifif.hpp"
#include "telif/logger.hpp"
#include "hlcc/cpputil/requestor.hpp"
#include <Eltpkif.hpp>
 
namespace hlcc::telif {
 
class DataContext;
 
class OffsetHandler {
 public:
    OffsetHandler(DataContext& data_ctx);
 
    virtual ~OffsetHandler();
 
    void PostOffset(const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args, std::shared_ptr<elt::mal::promise<std::string>> prom_resp);
 
 
 private:
    FRIEND_TEST(TestOffsetHandler, OffsetArgsAsString);
    FRIEND_TEST(TestOffsetHandler, DdsExecuteHandshakeWithSequence);
    FRIEND_TEST(TestOffsetHandler, DdsSendOffsetArgumentsToSequence);
    FRIEND_TEST(TestOffsetHandler, DdsWaitForSequenceToFinish);
    FRIEND_TEST(TestOffsetHandler, CheckReceivedMessage);
    FRIEND_TEST(TestOffsetHandler, DdsPublishOffsetCompleted);
 
    void ProcessOffset(const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args, std::shared_ptr<elt::mal::promise<std::string>> prom_resp);
 
    void SendOffsetDirectly(const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    void SendOffsetAsSequenceHeadless(
        const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    void SendOffsetAsSequenceGui(
        const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    void SendOffsetAsPythonScript(
        const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    void SendOffsetAsSequenceDirect(
        const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    std::string OffsetArgsAsString(
        const std::shared_ptr<::ccsinsif::OffsetSkyArgs> &offset_sky_args);
 
    void DdsExecuteHandshakeWithSequence(uint16_t session_id);
 
    void DdsSendOffsetArgumentsToSequence(uint16_t session_id, std::string offset_args);
 
    void DdsWaitForSequenceToFinish(uint16_t session_id);
 
    void DdsPublishOffsetCompleted(uint16_t session_id);
 
    bool CheckReceivedMessage(uint16_t session_id, std::string message);
 
    /* Member variables */
    DataContext& m_data_ctx;                        // Reference to data context
 
    boost::asio::thread_pool m_offset_thread_pool;  // Pool of 1 thread for sending offset
 
    mutable std::recursive_mutex m_mutex;           // mutex to guard the execution of async offset
                                                    // as a sequence execution
 
    uint16_t m_last_session_id;                     // We will use this var to store the id of the
                                                    // last sequence execution session
                                                    // This way we ensure to use always a different
                                                    // session id for each execution of a sequence.
 
    std::vector<std::shared_ptr<telifif::SeqMessage>> m_received_msg; // Buffer to messages
                                                    // received from sequence
 
    hlcc::cpputil::Requestor<eltpkif::PointingKernelCommandsAsync> m_ptk_client;
 
};
 
}  // namespace hlcc::telif
 
#endif  // HLCC_TELIF_TELIF_OFFSETHANDLER_HPP