unpacker.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2016, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_UNPACKER_HPP
#define CPPWAMP_UNPACKER_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <functional>
#include <tuple>
#include "api.hpp"
#include "config.hpp"
#include "peerdata.hpp"
#include "traits.hpp"
#include "variant.hpp"
#include "./internal/integersequence.hpp"
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot>
using DecayedSlot = typename std::decay<TSlot>::type;
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename... TArgs>
class CPPWAMP_API EventUnpacker
{
public:
    using Slot = TSlot;
 
    explicit EventUnpacker(Slot slot);
 
    void operator()(Event event) const;
 
private:
    template <int ...S>
    void invoke(Event&& event, internal::IntegerSequence<S...>) const;
 
    Slot slot_;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
CPPWAMP_API EventUnpacker<DecayedSlot<TSlot>, TArgs...>
unpackedEvent(TSlot&& slot);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename... TArgs>
class CPPWAMP_API SimpleEventUnpacker
{
public:
    using Slot = TSlot;
 
    explicit SimpleEventUnpacker(Slot slot);
 
    void operator()(Event event) const;
 
private:
    template <int ...S>
    CPPWAMP_HIDDEN void invoke(Event&& event,
                               internal::IntegerSequence<S...>) const;
 
    Slot slot_;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename... TArgs>
using BasicEventUnpacker CPPWAMP_DEPRECATED
    = SimpleEventUnpacker<TSlot, TArgs...>;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
CPPWAMP_API SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...>
simpleEvent(TSlot&& slot);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
CPPWAMP_API SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...>
basicEvent(TSlot&& slot);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename... TArgs>
class CPPWAMP_API InvocationUnpacker
{
public:
    using Slot = TSlot;
 
    explicit InvocationUnpacker(Slot slot);
 
    Outcome operator()(Invocation inv) const;
 
private:
    template <int ...S>
    CPPWAMP_HIDDEN Outcome invoke(Invocation&& inv,
                                  internal::IntegerSequence<S...>) const;
 
    Slot slot_;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
CPPWAMP_API InvocationUnpacker<DecayedSlot<TSlot>, TArgs...>
unpackedRpc(TSlot&& slot);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename TResult, typename... TArgs>
class CPPWAMP_API SimpleInvocationUnpacker
{
public:
    using Slot = TSlot;
 
    using ResultType = TResult;
 
    explicit SimpleInvocationUnpacker(Slot slot);
 
    Outcome operator()(Invocation inv) const;
 
private:
    template <int ...S>
    Outcome invoke(TrueType, Invocation&& inv,
                   internal::IntegerSequence<S...>) const;
 
    template <int ...S>
    Outcome invoke(FalseType, Invocation&& inv,
                   internal::IntegerSequence<S...>) const;
 
    Slot slot_;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSlot, typename TResult, typename... TArgs>
using BasicInvocationUnpacker CPPWAMP_DEPRECATED =
    SimpleInvocationUnpacker<TSlot, TResult, TArgs...>;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TResult, typename... TArgs, typename TSlot>
CPPWAMP_API SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>
simpleRpc(TSlot&& slot);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TResult, typename... TArgs, typename TSlot>
CPPWAMP_API SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>
basicRpc(TSlot&& slot);
 
 
 
//******************************************************************************
// Internal helper types
//******************************************************************************
 
namespace internal
{
 
//------------------------------------------------------------------------------
// This is caught internally by Client while dispatching RPCs and is never
// propagated through the API.
//------------------------------------------------------------------------------
struct UnpackError : public Error
{
    UnpackError() : Error("wamp.error.invalid_argument") {}
};
 
} // namespace internal
 
 
//******************************************************************************
// EventUnpacker implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
EventUnpacker<S,A...>::EventUnpacker(Slot slot)
    : slot_(std::move(slot))
{}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
void EventUnpacker<S,A...>::operator()(Event event) const
{
    if (event.args().size() < sizeof...(A))
    {
        std::ostringstream oss;
        oss << "Expected " << sizeof...(A)
            << " args, but only got " << event.args().size();
        throw internal::UnpackError().withArgs(oss.str());
    }
 
    // Use the integer parameter pack technique shown in
    // http://stackoverflow.com/a/7858971/245265
    using Seq = typename internal::GenIntegerSequence<sizeof...(A)>::type;
    invoke(std::move(event), Seq());
}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
template <int ...Seq>
void EventUnpacker<S,A...>::invoke(Event&& event,
                                   internal::IntegerSequence<Seq...>) const
{
    std::tuple<ValueTypeOf<A>...> args;
 
    try
    {
        event.convertToTuple(args);
    }
    catch (const error::Conversion& e)
    {
        throw internal::UnpackError().withArgs(e.what());
    }
 
    slot_(std::move(event), std::get<Seq>(std::move(args))...);
}
 
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
EventUnpacker<DecayedSlot<TSlot>, TArgs...> unpackedEvent(TSlot&& slot)
{
    return EventUnpacker<DecayedSlot<TSlot>, TArgs...>(
        std::forward<TSlot>(slot));
}
 
 
//******************************************************************************
// SimpleEventUnpacker implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
SimpleEventUnpacker<S,A...>::SimpleEventUnpacker(Slot slot)
    : slot_(std::move(slot))
{}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
void SimpleEventUnpacker<S,A...>::operator()(Event event) const
{
    if (event.args().size() < sizeof...(A))
    {
        std::ostringstream oss;
        oss << "Expected " << sizeof...(A)
            << " args, but only got " << event.args().size();
        throw internal::UnpackError().withArgs(oss.str());
    }
 
    // Use the integer parameter pack technique shown in
    // http://stackoverflow.com/a/7858971/245265
    using Seq = typename internal::GenIntegerSequence<sizeof...(A)>::type;
    invoke(std::move(event), Seq());
}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
template <int ...Seq>
void SimpleEventUnpacker<S,A...>::invoke(Event&& event,
                                         internal::IntegerSequence<Seq...>) const
{
    std::tuple<ValueTypeOf<A>...> args;
 
    try
    {
        event.convertToTuple(args);
    }
    catch (const error::Conversion& e)
    {
        throw internal::UnpackError().withArgs(e.what());
    }
 
    slot_(std::get<Seq>(std::move(args))...);
}
 
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...> simpleEvent(TSlot&& slot)
{
    return SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...>(
        std::forward<TSlot>(slot));
}
 
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...> basicEvent(TSlot&& slot)
{
    return SimpleEventUnpacker<DecayedSlot<TSlot>, TArgs...>(
        std::forward<TSlot>(slot));
}
 
 
//******************************************************************************
// InvocationUnpacker implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
InvocationUnpacker<S,A...>::InvocationUnpacker(Slot slot)
    : slot_(std::move(slot))
{}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
Outcome InvocationUnpacker<S,A...>::operator()(Invocation inv) const
{
    if (inv.args().size() < sizeof...(A))
    {
        std::ostringstream oss;
        oss << "Expected " << sizeof...(A)
            << " args, but only got " << inv.args().size();
        throw internal::UnpackError().withArgs(oss.str());
    }
 
    // Use the integer parameter pack technique shown in
    // http://stackoverflow.com/a/7858971/245265
    using Seq = typename internal::GenIntegerSequence<sizeof...(A)>::type;
    return invoke(std::move(inv), Seq());
}
 
//------------------------------------------------------------------------------
template <typename S, typename... A>
template <int ...Seq>
Outcome
InvocationUnpacker<S,A...>::invoke(Invocation&& inv,
                                   internal::IntegerSequence<Seq...>) const
{
    std::tuple<ValueTypeOf<A>...> args;
 
    try
    {
        inv.convertToTuple(args);
    }
    catch (const error::Conversion& e)
    {
        throw internal::UnpackError().withArgs(e.what());
    }
 
    return slot_(std::move(inv), std::get<Seq>(std::move(args))...);
}
 
//------------------------------------------------------------------------------
template <typename... TArgs, typename TSlot>
InvocationUnpacker<DecayedSlot<TSlot>, TArgs...> unpackedRpc(TSlot&& slot)
{
    return InvocationUnpacker<DecayedSlot<TSlot>, TArgs...>(
        std::forward<TSlot>(slot) );
}
 
 
//******************************************************************************
// SimpleInvocationUnpacker implementation
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename S, typename R, typename... A>
SimpleInvocationUnpacker<S,R,A...>::SimpleInvocationUnpacker(Slot slot)
    : slot_(std::move(slot))
{}
 
//------------------------------------------------------------------------------
template <typename S, typename R, typename... A>
Outcome SimpleInvocationUnpacker<S,R,A...>::operator()(Invocation inv) const
{
    if (inv.args().size() < sizeof...(A))
    {
        std::ostringstream oss;
        oss << "Expected " << sizeof...(A)
            << " args, but only got " << inv.args().size();
        throw internal::UnpackError().withArgs(oss.str());
    }
 
    // Use the integer parameter pack technique shown in
    // http://stackoverflow.com/a/7858971/245265
    using Seq = typename internal::GenIntegerSequence<sizeof...(A)>::type;
    using IsVoidResult = BoolConstant<std::is_same<ResultType, void>::value>;
    return invoke(IsVoidResult{}, std::move(inv), Seq());
}
 
//------------------------------------------------------------------------------
template <typename S, typename R, typename... A>
template <int ...Seq>
Outcome SimpleInvocationUnpacker<S,R,A...>::invoke(
    TrueType, Invocation&& inv, internal::IntegerSequence<Seq...>) const
{
    std::tuple<ValueTypeOf<A>...> args;
 
    try
    {
        inv.convertToTuple(args);
    }
    catch (const error::Conversion& e)
    {
        throw internal::UnpackError().withArgs(e.what());
    }
 
    slot_(std::get<Seq>(std::move(args))...);
    return {};
}
 
//------------------------------------------------------------------------------
template <typename S, typename R, typename... A>
template <int ...Seq>
Outcome SimpleInvocationUnpacker<S,R,A...>::invoke(
    FalseType, Invocation&& inv, internal::IntegerSequence<Seq...>) const
{
    std::tuple<ValueTypeOf<A>...> args;
 
    try
    {
        inv.convertToTuple(args);
    }
    catch (const error::Conversion& e)
    {
        throw internal::UnpackError().withArgs(e.what());
    }
 
    ResultType result = slot_(std::get<Seq>(std::move(args))...);
    return Result().withArgs(std::move(result));
}
 
//------------------------------------------------------------------------------
template <typename TResult, typename... TArgs, typename TSlot>
SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>
simpleRpc(TSlot&& slot)
{
    return SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>(
        std::forward<TSlot>(slot) );
}
 
//------------------------------------------------------------------------------
template <typename TResult, typename... TArgs, typename TSlot>
SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>
basicRpc(TSlot&& slot)
{
    return SimpleInvocationUnpacker<DecayedSlot<TSlot>, TResult, TArgs...>(
        std::forward<TSlot>(slot) );
}
 
} // namespace wamp
 
#endif // CPPWAMP_UNPACKER_HPP