initiate.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdaq
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Contains declarations for the helper functions to initiate operations
 */
#ifndef OCM_DAQ_OP_INITIATE_HPP_
#define OCM_DAQ_OP_INITIATE_HPP_
#include "../config.hpp"
 
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
 
#include <boost/thread/future.hpp>
 
#include <rad/ioExecutor.hpp>
 
namespace daq::op {
 
/**
 * Constructs and initiates `Op` and return the future result.
 *
 * InitiateOperation performs the following:
 *
 * 1. Constructs the operation by forwarding the parameters Params.
 * 2. Invokes `Op::Initiate() -> boost::future<R>`
 * 3. Returns result of `Op::Initiate()`.
 * 4. Keeps Operation alive until result of `Op::Initiate()` is set, such that
 * the operation itself does not have to manage this.
 *
 *
 * Type Requirements:
 *
 * `Op`:
 *   `Op::Op(Params...)`
 *   `Op::Initiate() -> boost::future<R>`
 */
template <class Op, class R = decltype(std::declval<Op&>().Initiate()), class... Params>
R InitiateOperation(rad::IoExecutor& ex, Params&&... params);
 
/**
 * Like InitiateOperation but in addition to returning the future
 * it also returns an unspecified object @a Abort that can be invoked to abort the operation.
 *
 * If @a Abort return true it will have invoked `Op::Abort()`.
 * If @a Abort return false the operation has already been completed and future value has been set.
 *
 * Type Requirements:
 *
 * `Op`:
 *   `Op::Op(Params...)`
 *   `Op::Initiate() -> boost::future<R>`
 *   `Op::Abort() -> void`
 *      note: It's not required that the future returned from Initiate() has a value set
 *            when returning from Abort.
 */
template <class Op, class R = decltype(std::declval<Op&>().Initiate()), class... Params>
std::pair<R, std::function<bool()>>
InitiateAbortableOperation(rad::IoExecutor& ex, Params&&... params);
 
//
// Implementation
//
template <class Op, class R, class... Params>
R InitiateOperation(rad::IoExecutor& ex, Params&&... params) {
    std::unique_ptr<Op> op = std::make_unique<Op>(std::forward<Params>(params)...);
    auto* ptr = op.get();
 
    // Add continuation that keeps operation alive
    return ptr->Initiate().then(ex, [op = std::move(op)](auto f) { return f.get(); });
}
 
template <class Op, class R, class... Params>
std::pair<R, std::function<bool()>>
InitiateAbortableOperation(rad::IoExecutor& ex, Params&&... params) {
    // AbortOperation needs a handle to Op so it can abort it. So in this case
    // we create a shared pointer instead of unique as in InitiateOperation.
    std::shared_ptr<Op> op = std::make_shared<Op>(std::forward<Params>(params)...);
    auto* ptr = op.get();
    auto weak = std::weak_ptr<Op>(op);
    return {// Add continuation that keeps operation alive
            ptr->Initiate().then(ex, [op = std::move(op)](auto f) { return f.get(); }),
            [weak = std::move(weak)]() mutable -> bool {
                if (auto op = weak.lock(); op) {
                    // m_operation is still valid
                    op->Abort();
                    // reset so that abort is a one-shot action
                    weak.reset();
                    return true;
                }
                return false;
            }};
}
 
}  // namespace daq::op
 
#endif  // #ifndef OCM_DAQ_OP_INITIATE_HPP_