slave_control_messenger.hpp

Go to the documentation of this file.

#ifndef CORAL_BUS_SLAVE_CONTROL_MESSENGER_HPP
#define CORAL_BUS_SLAVE_CONTROL_MESSENGER_HPP

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

#include "boost/noncopyable.hpp"

#include "coral/config.h"

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


namespace coral
{
namespace bus
{


enum SlaveState
{
    SLAVE_NOT_CONNECTED,
    SLAVE_CONNECTED,    // For internal use
    SLAVE_READY,        
    SLAVE_STEP_OK,      
    SLAVE_STEP_FAILED,  
    SLAVE_BUSY,         
};


// Internal types, intentionally left undefined and undocumented.
class PendingSlaveControlConnectionPrivate;
struct SlaveControlConnectionPrivate;


class PendingSlaveControlConnection
{
public:
    explicit PendingSlaveControlConnection(
        std::shared_ptr<PendingSlaveControlConnectionPrivate> p = nullptr) CORAL_NOEXCEPT;
    PendingSlaveControlConnection(PendingSlaveControlConnection&&) CORAL_NOEXCEPT;
    PendingSlaveControlConnection& operator=(PendingSlaveControlConnection&&) CORAL_NOEXCEPT;
    ~PendingSlaveControlConnection() CORAL_NOEXCEPT;

    void Close();

    operator bool() const CORAL_NOEXCEPT;

private:
    std::shared_ptr<PendingSlaveControlConnectionPrivate> m_private;
};


class SlaveControlConnection
{
public:
    SlaveControlConnection() CORAL_NOEXCEPT;

    // For internal use.
    explicit SlaveControlConnection(
        std::unique_ptr<SlaveControlConnectionPrivate> p) CORAL_NOEXCEPT;

    SlaveControlConnection(SlaveControlConnection&&) CORAL_NOEXCEPT;

    SlaveControlConnection& operator=(SlaveControlConnection&&) CORAL_NOEXCEPT;

    ~SlaveControlConnection() CORAL_NOEXCEPT;

    operator bool() const CORAL_NOEXCEPT;

    // For internal use.
    SlaveControlConnectionPrivate& Private();

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


class ISlaveControlMessenger : boost::noncopyable
{
public:
    typedef std::function<void(const std::error_code&)> VoidHandler;

    virtual ~ISlaveControlMessenger() CORAL_NOEXCEPT { }

    virtual SlaveState State() const CORAL_NOEXCEPT = 0;

    virtual void Close() = 0;


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

    virtual void GetDescription(
        std::chrono::milliseconds timeout,
        GetDescriptionHandler onComplete) = 0;


    typedef VoidHandler SetVariablesHandler;

    virtual void SetVariables(
        const std::vector<coral::model::VariableSetting>& settings,
        std::chrono::milliseconds timeout,
        SetVariablesHandler onComplete) = 0;


    typedef VoidHandler SetPeersHandler;

    virtual void SetPeers(
        const std::vector<coral::net::Endpoint>& peer,
        std::chrono::milliseconds timeout,
        SetPeersHandler onComplete) = 0;


    typedef VoidHandler ResendVarsHandler;

    virtual void ResendVars(
        std::chrono::milliseconds timeout,
        ResendVarsHandler onComplete) = 0;


    typedef VoidHandler StepHandler;

    virtual void Step(
        coral::model::StepID stepID,
        coral::model::TimePoint currentT,
        coral::model::TimeDuration deltaT,
        std::chrono::milliseconds timeout,
        StepHandler onComplete) = 0;


    typedef VoidHandler AcceptStepHandler;

    virtual void AcceptStep(
        std::chrono::milliseconds timeout,
        AcceptStepHandler onComplete) = 0;

    virtual void Terminate() = 0;
};


typedef std::function<void(const std::error_code&, SlaveControlConnection)>
    ConnectToSlaveHandler;


PendingSlaveControlConnection ConnectToSlave(
    coral::net::Reactor& reactor,
    const coral::net::SlaveLocator& slaveLocator,
    int maxAttempts,
    std::chrono::milliseconds timeout,
    ConnectToSlaveHandler onComplete);


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

std::unique_ptr<ISlaveControlMessenger> MakeSlaveControlMessenger(
    SlaveControlConnection connection,
    coral::model::SlaveID slaveID,
    const std::string& slaveName,
    const SlaveSetup& setup,
    MakeSlaveControlMessengerHandler onComplete);


}} // namespace
#endif // header guard