Generator.h

Go to the documentation of this file.

 
#pragma once
 
#include "RobotRaconteur/DataTypes.h"
#include "RobotRaconteur/Endpoint.h"
#include "RobotRaconteur/Client.h"
#include "RobotRaconteur/Service.h"
 
namespace RobotRaconteur
{
 
template <typename Return, typename Param>
class Generator : private boost::noncopyable
{
  public:
    virtual Return Next(const Param& v) = 0;
    virtual bool TryNext(const Param& v, Return& ret)
    {
        // TODO: This is not the most efficient implementation
        try
        {
            ret = Next(v);
            return true;
        }
        catch (StopIterationException&)
        {
            return false;
        }
    }

    virtual void AsyncNext(
        const Param& v, boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Abort() = 0;
    virtual void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Close() = 0;
    virtual void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual ~Generator() {}
};

template <typename Return>
class Generator<Return, void> : private boost::noncopyable
{
  public:
    virtual Return Next() = 0;

    virtual bool TryNext(Return& ret)
    {
        try
        {
            ret = Next();
            return true;
        }
        catch (StopIterationException&)
        {
            return false;
        }
    }

    virtual void AsyncNext(
        boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Abort() = 0;
    virtual void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Close() = 0;
    virtual void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual std::vector<Return> NextAll()
    {
        std::vector<Return> ret;
        try
        {
            while (true)
            {
                ret.push_back(Next());
            }
        }
        catch (StopIterationException&)
        {}
        return ret;
    }
    virtual ~Generator() {}
};

template <typename Param>
class Generator<void, Param> : private boost::noncopyable
{
  public:
    virtual void Next(const Param& v) = 0;

    virtual bool TryNext(const Param& v)
    {
        try
        {
            Next(v);
        }
        catch (StopIterationException&)
        {
            return false;
        }
        return true;
    }

    virtual void AsyncNext(const Param& v,
                           boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                           int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Abort() = 0;
    virtual void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual void Close() = 0;
    virtual void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE) = 0;
    virtual ~Generator() {}
};
 
class ROBOTRACONTEUR_CORE_API GeneratorClientBase
{
  protected:
    std::string name;
    int32_t id;
    RR_WEAK_PTR<ServiceStub> stub;
    RR_WEAK_PTR<RobotRaconteurNode> node;
    uint32_t endpoint;
    std::string service_path;
 
    GeneratorClientBase(boost::string_ref name, int32_t id, const RR_SHARED_PTR<ServiceStub>& stub);
 
    virtual RR_INTRUSIVE_PTR<MessageElement> NextBase(const RR_INTRUSIVE_PTR<MessageElement>& v);
    virtual void AsyncNextBase(
        const RR_INTRUSIVE_PTR<MessageElement>& v,
        boost::function<void(const RR_INTRUSIVE_PTR<MessageElement>&, const RR_SHARED_PTR<RobotRaconteurException>&,
                             const RR_SHARED_PTR<RobotRaconteurNode>&)>
            handler,
        int32_t timeout);
 
    static void AsyncNextBase1(
        const RR_INTRUSIVE_PTR<MessageEntry>& ret, const RR_SHARED_PTR<RobotRaconteurException>& err,
        boost::function<void(const RR_INTRUSIVE_PTR<MessageElement>&, const RR_SHARED_PTR<RobotRaconteurException>&,
                             const RR_SHARED_PTR<RobotRaconteurNode>&)>
            handler,
        const RR_WEAK_PTR<RobotRaconteurNode>& node);
 
  public:
    RR_SHARED_PTR<ServiceStub> GetStub();
 
    virtual void Abort();
    virtual void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE);
    virtual void Close();
    virtual void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                            int32_t timeout = RR_TIMEOUT_INFINITE);
    std::string GetMemberName();
 
    virtual ~GeneratorClientBase() {}
};
 
namespace detail
{
template <typename Return>
static void GeneratorClient_AsyncNext1(
    const RR_INTRUSIVE_PTR<MessageElement>& v2, const RR_SHARED_PTR<RobotRaconteurException>& err,
    const RR_SHARED_PTR<RobotRaconteurNode>& node,
    boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>&)> handler)
{
    if (err)
    {
        detail::InvokeHandlerWithException(node, handler, err);
        return;
    }
    Return ret;
    try
    {
        ret = RRPrimUtil<Return>::PreUnpack(node->UnpackAnyType<typename RRPrimUtil<Return>::BoxedType>(v2));
    }
    catch (std::exception& e)
    {
        detail::InvokeHandlerWithException(node, handler, e);
        return;
    }
    detail::InvokeHandler<Return>(node, handler, ret);
}
 
ROBOTRACONTEUR_CORE_API void GeneratorClient_AsyncNext2(
    const RR_INTRUSIVE_PTR<MessageElement>& v2, const RR_SHARED_PTR<RobotRaconteurException>& err,
    const RR_SHARED_PTR<RobotRaconteurNode>& node,
    boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler);
} // namespace detail
 
template <typename Return, typename Param>
class GeneratorClient : public Generator<Return, Param>, public GeneratorClientBase
{
  public:
    GeneratorClient(boost::string_ref name, int32_t id, const RR_SHARED_PTR<ServiceStub>& stub)
        : GeneratorClientBase(name, id, stub)
    {}
 
    RR_OVIRTUAL Return Next(const Param& v) RR_OVERRIDE
    {
        RR_INTRUSIVE_PTR<MessageElement> v1 = CreateMessageElement(
            "", GetStub()->RRGetNode()->template PackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    RRPrimUtil<Param>::PrePack(v)));
        RR_INTRUSIVE_PTR<MessageElement> v2 = NextBase(v1);
        return RRPrimUtil<Return>::PreUnpack(
            GetStub()->RRGetNode()->template UnpackAnyType<typename RRPrimUtil<Return>::BoxedType>(v2));
    }
    RR_OVIRTUAL void AsyncNext(
        const Param& v, boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_INTRUSIVE_PTR<MessageElement> v1 = CreateMessageElement(
            "", GetStub()->RRGetNode()->template PackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    RRPrimUtil<Param>::PrePack(v)));
        AsyncNextBase(v1,
                      boost::bind<void>(&detail::GeneratorClient_AsyncNext1<Return>, RR_BOOST_PLACEHOLDERS(_1),
                                        RR_BOOST_PLACEHOLDERS(_2), RR_BOOST_PLACEHOLDERS(_3), handler),
                      timeout);
    }
    RR_OVIRTUAL void Abort() RR_OVERRIDE { GeneratorClientBase::Abort(); }
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
    RR_OVIRTUAL void Close() RR_OVERRIDE { GeneratorClientBase::Close(); }
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
};
 
template <typename Return>
class GeneratorClient<Return, void> : public Generator<Return, void>, public GeneratorClientBase
{
  public:
    GeneratorClient(boost::string_ref name, int32_t id, const RR_SHARED_PTR<ServiceStub>& stub)
        : GeneratorClientBase(name, id, stub)
    {}
 
    RR_OVIRTUAL Return Next() RR_OVERRIDE
    {
        RR_INTRUSIVE_PTR<MessageElement> v2 = NextBase(RR_INTRUSIVE_PTR<MessageElement>());
        return RRPrimUtil<Return>::PreUnpack(
            GetStub()->RRGetNode()->template UnpackAnyType<typename RRPrimUtil<Return>::BoxedType>(v2));
    }
    RR_OVIRTUAL void AsyncNext(
        boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        AsyncNextBase(RR_INTRUSIVE_PTR<MessageElement>(),
                      boost::bind<void>(&detail::GeneratorClient_AsyncNext1<Return>, RR_BOOST_PLACEHOLDERS(_1),
                                        RR_BOOST_PLACEHOLDERS(_2), RR_BOOST_PLACEHOLDERS(_3), handler),
                      timeout);
    }
    RR_OVIRTUAL void Abort() RR_OVERRIDE { GeneratorClientBase::Abort(); }
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
    RR_OVIRTUAL void Close() RR_OVERRIDE { GeneratorClientBase::Close(); }
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
};
 
template <typename Param>
class GeneratorClient<void, Param> : public Generator<void, Param>, public GeneratorClientBase
{
  public:
    GeneratorClient(boost::string_ref name, int32_t id, const RR_SHARED_PTR<ServiceStub>& stub)
        : GeneratorClientBase(name, id, stub)
    {}
 
    RR_OVIRTUAL void Next(const Param& v) RR_OVERRIDE
    {
        RR_INTRUSIVE_PTR<MessageElement> v1 = CreateMessageElement(
            "", GetStub()->RRGetNode()->template PackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    RRPrimUtil<Param>::PrePack(v)));
        NextBase(v1);
    }
    RR_OVIRTUAL void AsyncNext(const Param& v,
                               boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                               int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_INTRUSIVE_PTR<MessageElement> v1 = CreateMessageElement(
            "", GetStub()->RRGetNode()->template PackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    RRPrimUtil<Param>::PrePack(v)));
        AsyncNextBase(v1,
                      boost::bind<void>(&detail::GeneratorClient_AsyncNext2, RR_BOOST_PLACEHOLDERS(_1),
                                        RR_BOOST_PLACEHOLDERS(_2), RR_BOOST_PLACEHOLDERS(_3), RR_MOVE(handler)),
                      timeout);
    }
    RR_OVIRTUAL void Abort() RR_OVERRIDE { GeneratorClientBase::Abort(); }
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
    RR_OVIRTUAL void Close() RR_OVERRIDE { GeneratorClientBase::Close(); }
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        GeneratorClientBase::AsyncAbort(handler, timeout);
    }
};
 
class ServerEndpoint;
 
class ROBOTRACONTEUR_CORE_API GeneratorServerBase : private boost::noncopyable
{
  protected:
    std::string name;
    int32_t index;
    RR_WEAK_PTR<ServiceSkel> skel;
    RR_INTRUSIVE_PTR<MessageElement> m;
    RR_SHARED_PTR<ServerEndpoint> ep;
    RR_WEAK_PTR<RobotRaconteurNode> node;
    std::string service_path;
 
    boost::posix_time::ptime last_access_time;
 
    GeneratorServerBase(boost::string_ref name, int32_t index, const RR_SHARED_PTR<ServiceSkel>& skel,
                        const RR_SHARED_PTR<ServerEndpoint>& ep);
 
  public:
    friend class ServiceSkel;
 
    virtual void CallNext(const RR_INTRUSIVE_PTR<MessageEntry>& m) = 0;
 
    virtual uint32_t GetEndpoint();
 
    virtual ~GeneratorServerBase() {}
 
  protected:
    static void EndAsyncCallNext(const RR_WEAK_PTR<ServiceSkel>& skel, const RR_INTRUSIVE_PTR<MessageElement>& ret,
                                 const RR_SHARED_PTR<RobotRaconteurException>& err, int32_t index,
                                 const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<ServerEndpoint>& ep);
 
    template <typename Return>
    static void CallNext1(Return v2, const RR_SHARED_PTR<RobotRaconteurException>& err, int32_t index,
                          const RR_WEAK_PTR<ServiceSkel>& skel, const RR_INTRUSIVE_PTR<MessageEntry>& m,
                          const RR_SHARED_PTR<ServerEndpoint>& ep)
    {
        RR_SHARED_PTR<ServiceSkel> skel1 = skel.lock();
        RR_SHARED_PTR<RobotRaconteurException> err2 = err;
        // TODO: Improve null handling
        if (!skel1 && !err2)
        {
            err2 = RR_MAKE_SHARED<InvalidOperationException>("Service skel released");
        }
        if (err2)
        {
            GeneratorServerBase::EndAsyncCallNext(skel, RR_INTRUSIVE_PTR<MessageElement>(), err2, index, m, ep);
        }
 
        RR_INTRUSIVE_PTR<MessageElement> v3 =
            CreateMessageElement("", skel1->RRGetNode()->template PackAnyType<typename RRPrimUtil<Return>::BoxedType>(
                                         RRPrimUtil<Return>::PrePack(v2)));
        GeneratorServerBase::EndAsyncCallNext(skel, v3, err, index, m, ep);
    }
 
    static void CallNext2(const RR_SHARED_PTR<RobotRaconteurException>& err, int32_t index,
                          const RR_WEAK_PTR<ServiceSkel>& skel, const RR_INTRUSIVE_PTR<MessageEntry>& m,
                          const RR_SHARED_PTR<ServerEndpoint>& ep)
    {
        RR_SHARED_PTR<ServiceSkel> skel1 = skel.lock();
        RR_SHARED_PTR<RobotRaconteurException> err2 = err;
        // TODO: Improve null handling
        if (!skel1 && !err2)
        {
            err2 = RR_MAKE_SHARED<InvalidOperationException>("Service skel released");
        }
        if (err2)
        {
            GeneratorServerBase::EndAsyncCallNext(skel, RR_INTRUSIVE_PTR<MessageElement>(), err2, index, m, ep);
        }
 
        RR_INTRUSIVE_PTR<MessageElement> v3;
        GeneratorServerBase::EndAsyncCallNext(skel, v3, err2, index, m, ep);
    }
};
 
template <typename Return, typename Param>
class GeneratorServer : public GeneratorServerBase
{
  protected:
    RR_SHARED_PTR<Generator<Return, Param> > generator;
 
  public:
    GeneratorServer(const RR_SHARED_PTR<Generator<Return, Param> >& generator, boost::string_ref name, int32_t id,
                    const RR_SHARED_PTR<ServiceSkel>& skel, const RR_SHARED_PTR<ServerEndpoint>& ep)
        : GeneratorServerBase(name, id, skel, ep)
    {
        if (!generator)
            throw InvalidOperationException("Generator must not be null");
        this->generator = generator;
    }
 
    RR_OVIRTUAL void CallNext(const RR_INTRUSIVE_PTR<MessageEntry>& m) RR_OVERRIDE
    {
        ROBOTRACONTEUR_LOG_TRACE_COMPONENT_PATH(node, Service, ep->GetLocalEndpoint(), service_path, name,
                                                "Generator CallNext with id " << index);
        RR_SHARED_PTR<ServiceSkel> skel1 = skel.lock();
        if (!skel1)
        {
            throw InvalidOperationException("Skel has been released");
        }
 
        if (m->Error != MessageErrorType_None)
        {
            if (m->Error == MessageErrorType_StopIteration)
            {
                generator->AsyncClose(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
            else
            {
                generator->AsyncAbort(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
        }
        else
        {
            Param v = RRPrimUtil<Param>::PreUnpack(
                skel1->RRGetNode()->template UnpackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    m->FindElement("parameter")));
            generator->AsyncNext(v,
                                 boost::bind<void>(&GeneratorServerBase::CallNext1<Return>, RR_BOOST_PLACEHOLDERS(_1),
                                                   RR_BOOST_PLACEHOLDERS(_2), index, skel, m, ep));
        }
    }
 
    RR_OVIRTUAL ~GeneratorServer() RR_OVERRIDE {}
};
 
template <typename Return>
class GeneratorServer<Return, void> : public GeneratorServerBase
{
  protected:
    RR_SHARED_PTR<Generator<Return, void> > generator;
 
  public:
    GeneratorServer(RR_SHARED_PTR<Generator<Return, void> > generator, boost::string_ref name, int32_t id,
                    const RR_SHARED_PTR<ServiceSkel>& skel, const RR_SHARED_PTR<ServerEndpoint>& ep)
        : GeneratorServerBase(name, id, skel, ep)
    {
        if (!generator)
            throw InvalidOperationException("Generator must not be null");
        this->generator = generator;
    }
 
    RR_OVIRTUAL void CallNext(const RR_INTRUSIVE_PTR<MessageEntry>& m) RR_OVERRIDE
    {
        RR_SHARED_PTR<ServiceSkel> skel1 = skel.lock();
        if (!skel1)
        {
            throw InvalidOperationException("Skel has been released");
        }
 
        if (m->Error != MessageErrorType_None)
        {
            if (m->Error == MessageErrorType_StopIteration)
            {
                generator->AsyncClose(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
            else
            {
                generator->AsyncAbort(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
        }
        else
        {
            generator->AsyncNext(boost::bind<void>(&GeneratorServerBase::CallNext1<Return>, RR_BOOST_PLACEHOLDERS(_1),
                                                   RR_BOOST_PLACEHOLDERS(_2), index, skel, m, ep));
        }
    }
    RR_OVIRTUAL ~GeneratorServer() RR_OVERRIDE {}
};
 
template <typename Param>
class GeneratorServer<void, Param> : public GeneratorServerBase
{
  protected:
    RR_SHARED_PTR<Generator<void, Param> > generator;
 
  public:
    GeneratorServer(RR_SHARED_PTR<Generator<void, Param> > generator, boost::string_ref name, int32_t id,
                    const RR_SHARED_PTR<ServiceSkel>& skel, const RR_SHARED_PTR<ServerEndpoint>& ep)
        : GeneratorServerBase(name, id, skel, ep)
    {
        if (!generator)
            throw InvalidOperationException("Generator must not be null");
        this->generator = generator;
    }
 
    RR_OVIRTUAL void CallNext(const RR_INTRUSIVE_PTR<MessageEntry>& m) RR_OVERRIDE
    {
        RR_SHARED_PTR<ServiceSkel> skel1 = skel.lock();
        if (!skel1)
        {
            throw InvalidOperationException("Skel has been released");
        }
 
        if (m->Error != MessageErrorType_None)
        {
            if (m->Error == MessageErrorType_StopIteration)
            {
                generator->AsyncClose(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
            else
            {
                generator->AsyncAbort(boost::bind<void>(&GeneratorServerBase::CallNext1<int32_t>, 0,
                                                        RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
            }
        }
        else
        {
            Param v = RRPrimUtil<Param>::PreUnpack(
                skel1->RRGetNode()->template UnpackAnyType<typename RRPrimUtil<Param>::BoxedType>(
                    m->FindElement("parameter")));
            generator->AsyncNext(
                v, boost::bind<void>(&GeneratorServerBase::CallNext2, RR_BOOST_PLACEHOLDERS(_1), index, skel, m, ep));
        }
    }
    RR_OVIRTUAL ~GeneratorServer() RR_OVERRIDE {}
};
 
// NOLINTBEGIN(cppcoreguidelines-virtual-class-destructor)

template <typename Return, typename Param>
class SyncGenerator : public Generator<Return, Param>
{
  public:
    RR_OVIRTUAL Return Next(const Param& v) RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncNext(
        const Param& v, boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        Return r;
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            r = Next(v);
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler, r);
    }

    RR_OVIRTUAL void Abort() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Abort();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }

    RR_OVIRTUAL void Close() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Close();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }
    RR_OVIRTUAL ~SyncGenerator() RR_OVERRIDE {}
};

template <typename Return>
class SyncGenerator<Return, void> : public Generator<Return, void>
{
  public:
    RR_OVIRTUAL Return Next() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncNext(
        boost::function<void(const Return&, const RR_SHARED_PTR<RobotRaconteurException>& err)> handler,
        int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        Return r;
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            r = Next();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler, r);
    }

    RR_OVIRTUAL void Abort() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Abort();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }

    RR_OVIRTUAL void Close() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Close();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }
    RR_OVIRTUAL ~SyncGenerator() RR_OVERRIDE {}
};

template <typename Param>
class SyncGenerator<void, Param> : public Generator<void, Param>
{
  public:
    RR_OVIRTUAL void Next(const Param& v) RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncNext(const Param& v,
                               boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                               int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Next(v);
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }

    RR_OVIRTUAL void Abort() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncAbort(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Abort();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }

    RR_OVIRTUAL void Close() RR_OVERRIDE = 0;
    RR_OVIRTUAL void AsyncClose(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)> handler,
                                int32_t timeout = RR_TIMEOUT_INFINITE) RR_OVERRIDE
    {
        RR_UNUSED(timeout);
        RR_WEAK_PTR<RobotRaconteurNode> node;
        try
        {
            Close();
        }
        catch (std::exception& exp)
        {
            detail::InvokeHandlerWithException(node, handler, exp);
            return;
        }
        detail::InvokeHandler(node, handler);
    }
    RR_OVIRTUAL ~SyncGenerator() RR_OVERRIDE {}
};
 
// NOLINTEND(cppcoreguidelines-virtual-class-destructor)

template <typename T>
class RangeGenerator : public SyncGenerator<typename T::value_type, void>
{
  protected:
    T range;
    typename T::iterator iter;
    boost::mutex range_lock;
    bool aborted;
 
  public:
    RangeGenerator(const T& range)
    {
        this->range = range;
        aborted = false;
        this->iter = this->range.begin();
    }

    RR_OVIRTUAL typename T::value_type Next() RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(range_lock);
 
        if (aborted)
        {
            throw OperationAbortedException("");
        }
 
        if (iter == range.end())
        {
            throw StopIterationException("");
        }
 
        return *iter++;
    }

    RR_OVIRTUAL void Abort() RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(range_lock);
        iter = range.end();
        aborted = true;
    }

    RR_OVIRTUAL void Close() RR_OVERRIDE
    {
        boost::mutex::scoped_lock lock(range_lock);
        iter = range.end();
    }
    RR_OVIRTUAL ~RangeGenerator() RR_OVERRIDE {}
};

template <typename T>
RR_SHARED_PTR<RangeGenerator<T> > CreateRangeGenerator(const T& range)
{
    return RR_MAKE_SHARED<RangeGenerator<T> >(range);
}
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
template <typename Return, typename Param>
using GeneratorPtr = RR_SHARED_PTR<Generator<Return, Param> >;
template <typename Return, typename Param>
using GeneratorConstPtr = RR_SHARED_PTR<const Generator<Return, Param> >;
template <typename T>
using RangeGeneratorPtr = RR_SHARED_PTR<RangeGenerator<T> >;
template <typename T>
using RangeGeneratorConstPtr = RR_SHARED_PTR<const RangeGenerator<T> >;
#endif
 
} // namespace RobotRaconteur