CallbackMember.h

Go to the documentation of this file.

 
#pragma once
 
#include "RobotRaconteur/DataTypes.h"
#include "RobotRaconteur/Endpoint.h"
#include "RobotRaconteur/Service.h"
 
namespace RobotRaconteur
{
template <typename T>
class Callback : private boost::noncopyable
{
 
  protected:
    std::string m_MemberName;
 
  public:
    Callback(boost::string_ref name) { m_MemberName = RR_MOVE(name.to_string()); }
 
    virtual ~Callback() {}
 
    virtual T GetFunction() = 0;
 
    virtual void SetFunction(T value) = 0;
 
    virtual T GetClientFunction(const RR_SHARED_PTR<Endpoint>& endpoint) = 0;
 
    virtual T GetClientFunction(uint32_t endpoint) = 0;
 
    virtual std::string GetMemberName() { return m_MemberName; }
 
    virtual void Shutdown() {}
};
 
template <typename T>
class CallbackClient : public Callback<T>
{
  public:
    CallbackClient(boost::string_ref name) : Callback<T>(name) {}
 
    RR_OVIRTUAL ~CallbackClient() RR_OVERRIDE {}
 
  private:
    T function;
    boost::mutex function_lock;
 
  public:
    RR_OVIRTUAL T GetFunction() RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(function_lock);
        if (!function)
            throw InvalidOperationException("Callback function not set");
        return function;
    }
    RR_OVIRTUAL void SetFunction(T value) RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(function_lock);
        function = value;
    }
 
    RR_OVIRTUAL T GetClientFunction(const RR_SHARED_PTR<Endpoint>& e) RR_OVERRIDE
    {
        RR_UNUSED(e);
        throw InvalidOperationException("Invalid for client side of callback");
    }
 
    RR_OVIRTUAL T GetClientFunction(uint32_t e) RR_OVERRIDE
    {
        RR_UNUSED(e);
        throw InvalidOperationException("Invalid for client side of callback");
    }
 
    RR_OVIRTUAL void Shutdown() RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(function_lock);
        function.clear();
    }
};
 
class ROBOTRACONTEUR_CORE_API ServiceSkel;
 
class ROBOTRACONTEUR_CORE_API CallbackServerBase
{
 
  public:
    virtual ~CallbackServerBase() {}
 
  protected:
    RR_WEAK_PTR<ServiceSkel> skel;
 
    virtual RR_SHARED_PTR<void> GetClientFunction_internal(uint32_t e);
 
    virtual std::string GetMemberName() = 0;
};
 
template <typename T>
class CallbackServer : public Callback<T>, public CallbackServerBase
{
  public:
    CallbackServer(boost::string_ref name, const RR_SHARED_PTR<ServiceSkel>& skel) : Callback<T>(name)
    {
        this->skel = skel;
    }
 
    RR_OVIRTUAL ~CallbackServer() RR_OVERRIDE {}
 
    RR_OVIRTUAL T GetFunction() RR_OVERRIDE { throw InvalidOperationException("Invalid for server side of callback"); }
    RR_OVIRTUAL void SetFunction(T value) RR_OVERRIDE
    {
        RR_UNUSED(value);
        throw InvalidOperationException("Invalid for server side of callback");
    }
 
    RR_OVIRTUAL T GetClientFunction(const RR_SHARED_PTR<Endpoint>& e) RR_OVERRIDE
    {
        RR_UNUSED(e);
        return GetClientFunction(e->GetLocalEndpoint());
    }
 
    RR_OVIRTUAL T GetClientFunction(uint32_t e) RR_OVERRIDE
    {
        RR_SHARED_PTR<ServiceSkel> s = skel.lock();
        if (!s)
            throw InvalidOperationException("Callback server has been closed");
        return *RR_STATIC_POINTER_CAST<T>(s->GetCallbackFunction(e, GetMemberName()));
    }
 
    RR_OVIRTUAL std::string GetMemberName() RR_OVERRIDE { return Callback<T>::GetMemberName(); }
 
    RR_OVIRTUAL void Shutdown() RR_OVERRIDE {}
};
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
template <typename T>
using CallbackPtr = RR_SHARED_PTR<Callback<T> >;
template <typename T>
using CallbackConstPtr = RR_SHARED_PTR<const Callback<T> >;
#endif
} // namespace RobotRaconteur