asyncOpParams.hpp

Go to the documentation of this file.

#ifndef DAQ_OP_ASYNC_OP_PARAMS_HPP_
#define DAQ_OP_ASYNC_OP_PARAMS_HPP_
 
#include <boost/asio/io_context.hpp>
#include <log4cplus/logger.h>
 
#include <rad/ioExecutor.hpp>
 
#include "../status.hpp"
#include "../eventLog.hpp"
#include "../pendingReplies.hpp"
#include "../source.hpp"
#include "../state.hpp"
#include "../utility.hpp"
 
namespace daq::op {
 
/**
 * Parameters required for each async operation.
 *
 * Caller is responsible for keeping objects alive for the duration of the operation.
 */
struct AsyncOpParams {
    AsyncOpParams(ObservableStatus const& status_arg,
                  ObservableEventLog& event_log_arg,
                  rad::IoExecutor& executor_arg,
                  log4cplus::Logger& logger_arg,
                  std::string const& id_arg,
                  PendingReplies& pending_replies_arg,
                  std::vector<Source<PrimSource>>& prim_sources_arg,
                  std::vector<Source<MetaSource>>& meta_sources_arg)
        : status(status_arg)
        , event_log(event_log_arg)
        , executor(executor_arg)
        , logger(logger_arg)
        , id(id_arg)
        , pending_replies(pending_replies_arg)
        , prim_sources(prim_sources_arg)
        , meta_sources(meta_sources_arg) {
    }
    AsyncOpParams(AsyncOpParams const&) = default;
    AsyncOpParams(AsyncOpParams&&) = default;
 
    /**
     * Async operations should not modify status directly
     * DaqController does that.
     */
    ObservableStatus const& status;
    ObservableEventLog& event_log;
    rad::IoExecutor& executor;
    log4cplus::Logger& logger;
    std::string const& id;
    PendingReplies& pending_replies;
    std::vector<Source<PrimSource>>& prim_sources;  ///< Note: Consider vector immutable!
    std::vector<Source<MetaSource>>& meta_sources;  ///< Note: Consider vector immutable!a
};
 
/**
 * Await specific parameters that is not provided with AsyncOpParams.
 *
 * @important The clients provided must be configured with a reply timeout that takes the wait
 * timeout into account, otherwise MAL will time out before reply is sent.
 */
struct AwaitOpParams {
    using Duration = std::chrono::milliseconds;
    AwaitOpParams(AsyncOpParams common_arg, AwaitOpParams::Duration wait_interval_arg) noexcept
        : common(common_arg), wait_interval(wait_interval_arg) {
    }
    AwaitOpParams(AwaitOpParams const&) = default;
    AwaitOpParams(AwaitOpParams&&) = default;
    
    AsyncOpParams common;
 
    /**
     * Total amount of time to wait for condition to be fulfilled.
     */
    Duration wait_interval;
};
 
} // namespace daq::op
 
#endif // #ifndef DAQ_OP_ASYNC_OP_PARAMS_HPP_