execution_manager.hpp

Go to the documentation of this file.

#ifndef CORAL_BUS_EXECUTION_MANAGER_HPP
#define CORAL_BUS_EXECUTION_MANAGER_HPP

#include <chrono>
#include <functional>
#include <memory>
#include <system_error>
#include <utility>
#include <vector>

#include "boost/noncopyable.hpp"

#include "coral/config.h"
#include "coral/master/execution_options.hpp"
#include "coral/model.hpp"
#include "coral/net.hpp"

#include "coral/bus/slave_controller.hpp"
#include "coral/bus/slave_setup.hpp"
#include "coral/net/reactor.hpp"


namespace coral
{
namespace bus
{


struct AddedSlave
{
    coral::net::SlaveLocator locator;

    std::string name;

    AddedSlave() CORAL_NOEXCEPT { }

    AddedSlave(coral::net::SlaveLocator locator_, std::string name_)
        : locator{std::move(locator_)}, name(std::move(name_))
    { }
};

struct SlaveConfig
{
    coral::model::SlaveID slaveID;
    std::vector<coral::model::VariableSetting> variableSettings;

    SlaveConfig() CORAL_NOEXCEPT { }
    SlaveConfig(
        coral::model::SlaveID slaveID_,
        std::vector<coral::model::VariableSetting> variableSettings_)
        : slaveID{slaveID_}
        , variableSettings(variableSettings_)
    { }
};


class ExecutionManagerPrivate;


class ExecutionManager : boost::noncopyable
{
public:
    ExecutionManager(
        coral::net::Reactor& reactor,
        const std::string& executionName,
        const coral::master::ExecutionOptions& options = coral::master::ExecutionOptions{});

    ~ExecutionManager();

    typedef std::function<void(const std::error_code&)> ReconstituteHandler;

    typedef std::function<void(const std::error_code&, coral::model::SlaveID, std::size_t)>
        SlaveReconstituteHandler;

    void Reconstitute(
        const std::vector<AddedSlave>& slavesToAdd,
        std::chrono::milliseconds commTimeout,
        ReconstituteHandler onComplete,
        SlaveReconstituteHandler onSlaveComplete = SlaveReconstituteHandler{});

    typedef std::function<void(const std::error_code&)> ReconfigureHandler;

    typedef std::function<void(const std::error_code&, coral::model::SlaveID, std::size_t)>
        SlaveReconfigureHandler;

    void Reconfigure(
        const std::vector<SlaveConfig>& slaveConfigs,
        std::chrono::milliseconds commTimeout,
        ReconfigureHandler onComplete,
        SlaveReconfigureHandler onSlaveComplete = SlaveReconfigureHandler{});

    typedef std::function<void(const std::error_code&)> StepHandler;

    typedef std::function<void(const std::error_code&, coral::model::SlaveID)>
        SlaveStepHandler;

    void Step(
        coral::model::TimeDuration stepSize,
        std::chrono::milliseconds timeout,
        StepHandler onComplete,
        SlaveStepHandler onSlaveStepComplete = nullptr);

    typedef std::function<void(const std::error_code&)> AcceptStepHandler;

    typedef std::function<void(const std::error_code&, coral::model::SlaveID)>
        SlaveAcceptStepHandler;

    void AcceptStep(
        std::chrono::milliseconds timeout,
        AcceptStepHandler onComplete,
        SlaveAcceptStepHandler onSlaveAcceptStepComplete = nullptr);

    void Terminate();

    const std::string& SlaveName(coral::model::SlaveID id) const;

private:
    std::unique_ptr<ExecutionManagerPrivate> m_private;
};


}} // namespace
#endif // header guard