execution.hpp

Go to the documentation of this file.

#ifndef CORAL_MASTER_EXECUTION_HPP
#define CORAL_MASTER_EXECUTION_HPP

#include <chrono>
#include <future>
#include <iterator>
#include <memory>
#include <string>
#include <vector>

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


namespace coral
{
namespace master
{


enum class StepResult
{
    failed    = 0,

    completed = 1
};


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

    std::string name;

    coral::model::SlaveID id = coral::model::INVALID_SLAVE_ID;

    std::error_code error;

    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 = coral::model::INVALID_SLAVE_ID;

    std::vector<coral::model::VariableSetting> variableSettings;

    std::error_code error;

    SlaveConfig() CORAL_NOEXCEPT { }

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



class Execution
{
public:
    explicit Execution(
        const std::string& executionName,
        const ExecutionOptions& options = ExecutionOptions{});

    ~Execution() CORAL_NOEXCEPT;

    Execution(const Execution&) = delete;
    Execution& operator=(const Execution&) = delete;

    Execution(Execution&&) CORAL_NOEXCEPT;

    Execution& operator=(Execution&&) CORAL_NOEXCEPT;

    void Reconstitute(
        std::vector<AddedSlave>& slavesToAdd,
        std::chrono::milliseconds commTimeout);

    void Reconfigure(
        std::vector<SlaveConfig>& slaveConfigs,
        std::chrono::milliseconds commTimeout);

    StepResult Step(
        coral::model::TimeDuration stepSize,
        std::chrono::milliseconds timeout,
        std::vector<std::pair<coral::model::SlaveID, StepResult>>* slaveResults = nullptr);

    void AcceptStep(std::chrono::milliseconds timeout);

    void Terminate();

private:
    class Private;
    std::unique_ptr<Private> m_private;
};


}}      //namespace
#endif  // header guard