Subscription.hpp

Go to the documentation of this file.

#ifndef SUBSCRIPTION_HPP
#define SUBSCRIPTION_HPP

#include <functional>
#include "Client.hpp"
#include "Message.hpp"
#include "PeriodicTimer.hpp"

namespace msp {
namespace client {

class SubscriptionBase {
public:
    SubscriptionBase() {}

    virtual ~SubscriptionBase() {}

    virtual void decode(msp::ByteVector& data) const = 0;

    virtual void makeRequest() const = 0;

    virtual void handleResponse() const = 0;

    virtual const msp::Message& getMsgObject() const = 0;

    bool isAutomatic() const {
        return hasTimer() && (timer_->getPeriod() > 0.0);
    }

    bool hasTimer() const { return timer_ ? true : false; }

    bool start() const { return this->timer_->start(); }

    bool stop() const { return this->timer_->stop(); }

    void setTimerPeriod(const double& period_seconds) {
        if(timer_) {
            timer_->setPeriod(period_seconds);
        }
        else if(period_seconds > 0.0) {
            timer_ = std::unique_ptr<PeriodicTimer>(new PeriodicTimer(
                std::bind(&SubscriptionBase::makeRequest, this),
                period_seconds));
            this->timer_->start();
        }
    }

    void setTimerFrequency(const double& rate_hz) {
        if(timer_) {
            timer_->setPeriod(1.0 / rate_hz);
        }
        else if(rate_hz > 0.0) {
            timer_ = std::unique_ptr<PeriodicTimer>(new PeriodicTimer(
                std::bind(&SubscriptionBase::makeRequest, this),
                1.0 / rate_hz));
            this->timer_->start();
        }
    }

protected:
    std::unique_ptr<PeriodicTimer> timer_;
};

template <typename T> class Subscription : public SubscriptionBase {
public:
    typedef std::function<void(const T&)> CallbackT;
    typedef std::function<void(const msp::Message&)> CallbackM;

    Subscription() {}

    Subscription(const CallbackT& recv_callback, const CallbackM& send_callback,
                 std::unique_ptr<T>&& io_object, const double& period = 0.0) :
        recv_callback_(recv_callback),
        send_callback_(send_callback),
        io_object_(std::move(io_object)) {
        if(period > 0.0) {
            timer_ = std::unique_ptr<PeriodicTimer>(new PeriodicTimer(
                std::bind(&Subscription<T>::makeRequest, this), period));
            this->timer_->start();
        }
    }

    virtual void decode(msp::ByteVector& data) const override {
        io_object_->decode(data);
        recv_callback_(*io_object_);
    }

    void setIoObject(std::unique_ptr<T>&& obj) const {
        io_object_ = std::move(obj);
    }

    const T& getIoObject() const { return *io_object_; }

    virtual const msp::Message& getMsgObject() const override {
        return *io_object_;
    }

    void setReceiveCallback(const CallbackT& recv_callback) const {
        recv_callback_ = recv_callback;
    }

    virtual void handleResponse() const override {
        if(recv_callback_) recv_callback_(*io_object_);
    }

    void setSendCallback(const CallbackM& send_callback) const {
        send_callback_ = send_callback;
    }

    virtual void makeRequest() const override {
        if(send_callback_) send_callback_(*io_object_);
    }

protected:
    CallbackT recv_callback_;
    CallbackM send_callback_;
    std::unique_ptr<T> io_object_;
};

}  // namespace client
}  // namespace msp

#endif