codec.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2015, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_CODEC_HPP
#define CPPWAMP_CODEC_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <istream>
#include <ostream>
#include "api.hpp"
#include "config.hpp"
#include "messagebuffer.hpp"
#include "traits.hpp"
#include "variant.hpp"
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API KnownCodecIds
{
    static constexpr int json() {return 1;}
    static constexpr int msgpack() {return 2;}
    static constexpr int cbor() {return 3;}
};
 
 
//******************************************************************************
// Encoder
//******************************************************************************
 
struct ByteContainerOutputCategory {};
 
struct StreamOutputCategory {};
 
struct UnknownOutputCategory {};
 
template <typename O, typename Enabled = void>
struct OutputCategory
{
    using type = UnknownOutputCategory;
};
 
template <typename O>
struct OutputCategory<O, EnableIf<std::is_base_of<std::ostream, O>::value,
                                  void>>
{
    using type = StreamOutputCategory;
};
 
template <typename O>
struct OutputCategory<O, EnableIf<!std::is_base_of<std::ostream, O>::value,
                                  void>>
{
    using type = ByteContainerOutputCategory;
};
 
template <typename O>
using OutputCategoryTypeOf = typename OutputCategory<ValueTypeOf<O>>::type;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename F, typename O, typename C = OutputCategoryTypeOf<O>>
using Encoder = typename F::template Encoder<ValueTypeOf<O>, C>;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TFormat, typename TOutput>
void encode(const Variant& variant, TOutput&& output)
{
    Encoder<TFormat, TOutput> encoder;
    encoder.encode(variant, std::forward<TOutput>(output));
}
 
 
//******************************************************************************
// Decoder
//******************************************************************************
 
struct ByteArrayInputCategory {};
 
struct StreamInputCategory {};
 
struct UnknownInputCategory {};
 
template <typename I, typename Enabled = void>
struct InputCategory
{
    using type = UnknownOutputCategory;
};
 
template <typename I>
struct InputCategory<I, EnableIf<std::is_base_of<std::istream, I>::value,
                                 void>>
{
    using type = StreamInputCategory;
};
 
template <typename I>
struct InputCategory<I, EnableIf<!std::is_base_of<std::istream, I>::value,
                                 void>>
{
    using type = ByteArrayInputCategory;
};
 
template <typename I>
using InputCategoryTypeOf = typename InputCategory<ValueTypeOf<I>>::type;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename F, typename I, typename C = InputCategoryTypeOf<I>>
using Decoder = typename F::template Decoder<ValueTypeOf<I>, C>;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TFormat, typename TInput>
CPPWAMP_NODISCARD std::error_code decode(TInput&& input, Variant& variant)
{
    Decoder<TFormat, TInput> decoder;
    return decoder.decode(std::forward<TInput>(input), variant);
}
 
} // namespace wamp
 
#endif // CPPWAMP_CODEC_HPP