awaitState.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdaq
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Contains declaration for the AwaitStateAsync operation
 */
#ifndef OCM_DAQ_OP_AWAIT_STATE_HPP_
#define OCM_DAQ_OP_AWAIT_STATE_HPP_
#include "../config.hpp"
 
#include <boost/asio/steady_timer.hpp>
#include <boost/signals2/connection.hpp>
#include <boost/thread/future.hpp>
#include <log4cplus/logger.h>
 
#include "../status.hpp"
#include "../utility.hpp"
 
 
namespace daq::op {
 
 
/**
 * Async operation to await Data Acquisition state
 *
 * Satisfies concept requirements for op::InitiateAbortableOperation and
 * op::InitiateOperation.
 *
 * @ingroup daq_common_libdaq
 */
struct AwaitStateAsync {
public:
    using ResultType = ::daq::Result<Status>;
    /**
     * Constructs operation with the privided parameters.
     *
     * @param io_ctx ASIO context.
     * @param status DAQ status to monitor/observe changes on.
     * @param state Target state.
     * @param timeout Operation timeout.
     */
    explicit AwaitStateAsync(boost::asio::io_context& io_ctx,
                             std::shared_ptr<ObservableStatus> status,
                             State state,
                             std::chrono::milliseconds timeout,
                             log4cplus::Logger const& logger);
 
    /**
     * Initiates operation that await state.
     *
     * @returns future with value being set when condition is satisifed or times out.
     * Exception DaqOperationAborted is set when operation is aborted.
     * ResultType::error is true if operation times out with await condition unsatisfied.
     *
     * @note Caller is responsible for keeping object alive until
     * result is set.
     */
    [[nodiscard]] boost::future<ResultType> Initiate();
 
    /**
     * Aborts the operation and completes the operation with DaqOperationAborted.
     */
    void Abort() noexcept;
 
private:
    bool IsConditionSatisfied() const;
    boost::asio::io_context& m_io_ctx;
    std::shared_ptr<ObservableStatus> m_status;
    State m_target;
    std::chrono::milliseconds m_timeout;
    /**
     * Indicates whether operation was aborted or not.
     *
     * If this is true it means that m_promise has already been fulfilled.
     */
    bool m_aborted;
 
    /**
     * Promise for future returned from `Initiate()`
     */
    boost::promise<ResultType> m_promise;
 
    boost::asio::steady_timer m_timer;
    boost::signals2::scoped_connection m_connection;
    log4cplus::Logger m_logger;
};
 
 
}  // namespace daq::op
#endif  // #ifndef OCM_DAQ_OP_AWAIT_STATE_HPP_