MessagePack for C++
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions
msgpack::type Namespace Reference

Namespaces

namespace  detail

Classes

struct  array_ref
struct  array_ref< T[N]>
struct  basic_variant
struct  define_array<>
struct  define_map<>
struct  tuple_type
struct  tuple_type< T & >
struct  tuple_type< const T & >
struct  tuple<>
struct  tuple_element
struct  const_tuple_element
struct  define_array_imp
struct  define_array_imp< Tuple, 1 >
struct  define_array
struct  define_map_imp
struct  define_map_imp< Tuple, 0 >
struct  define_map
class  tuple
class  ext
class  ext_ref
struct  fix_int
class  assoc_vector
struct  nil_t
struct  raw_ref
struct  size_equal_only
struct  v4raw_ref

Typedefs

typedef basic_variant< std::string, std::vector< char >, ext > variant
typedef basic_variant< std::string, raw_ref, ext_ref > variant_ref
typedef fix_int< uint8_t > fix_uint8
typedef fix_int< uint16_t > fix_uint16
typedef fix_int< uint32_t > fix_uint32
typedef fix_int< uint64_t > fix_uint64
typedef fix_int< int8_t > fix_int8
typedef fix_int< int16_t > fix_int16
typedef fix_int< int32_t > fix_int32
typedef fix_int< int64_t > fix_int64
typedef nil_t nil

Enumerations

enum  object_type {
  NIL = 0x00 , BOOLEAN = 0x01 , POSITIVE_INTEGER = 0x02 , NEGATIVE_INTEGER = 0x03 ,
  FLOAT32 = 0x0a , FLOAT64 = 0x04 , FLOAT = 0x04 , STR = 0x05 ,
  BIN = 0x06 , ARRAY = 0x07 , MAP = 0x08 , EXT = 0x09
}

Functions

template<typename T>
msgpack::enable_if<!msgpack::is_array< Tconst >::value, array_ref< Tconst > >::type make_array_ref (const T &t)
template<typename T>
msgpack::enable_if<!msgpack::is_array< T >::value, array_ref< T > >::type make_array_ref (T &t)
template<typename T, std::size_t N>
array_ref< const T[N]> make_array_ref (const T(&t)[N])
template<typename T, std::size_t N>
array_ref< T[N]> make_array_ref (T(&t)[N])
template<typename STR, typename BIN, typename EXT>
bool operator< (basic_variant< STR, BIN, EXT > const &lhs, basic_variant< STR, BIN, EXT > const &rhs)
template<typename STR, typename BIN, typename EXT>
bool operator== (basic_variant< STR, BIN, EXT > const &lhs, basic_variant< STR, BIN, EXT > const &rhs)
template<typename STR, typename BIN, typename EXT>
bool operator!= (basic_variant< STR, BIN, EXT > const &lhs, basic_variant< STR, BIN, EXT > const &rhs)
define_array make_define_array ()
define_map make_define_map ()
tuple make_tuple ()
template<typename T>
std::enable_if< has_as< T >::value >::type convert_helper (msgpack::object const &o, T &t)
template<typename T>
std::enable_if<!has_as< T >::value >::type convert_helper (msgpack::object const &o, T &t)
template<typename... Args>
define_array< Args... > make_define_array (Args &... args)
template<typename... Args>
define_map< Args... > make_define_map (Args &... args)
template<class... Args>
tuple< Args... > make_tuple (Args &&... args)
template<class... Args>
tuple< Args &&... > forward_as_tuple (Args &&... args) noexcept
template<class... Tuples>
auto tuple_cat (Tuples &&... args) -> decltype(std::tuple_cat(std::forward< typename std::remove_reference< Tuples >::type::base >(args)...))
template<class... Args>
tuple< Args &... > tie (Args &... args)
bool operator< (nil_t const &lhs, nil_t const &rhs)
bool operator== (nil_t const &lhs, nil_t const &rhs)
template<typename T>
std::size_t size (T const &t)
template<typename T, std::size_t N>
std::size_t size (const T(&)[N])
template<typename... T>
std::size_t size (std::tuple< T... > const &)
template<typename T>
size_equal_only< T > make_size_equal_only (T &t)
template<typename T>
bool operator< (size_equal_only< T > const &lhs, size_equal_only< T > const &rhs)
template<typename T>
bool operator== (size_equal_only< T > const &lhs, size_equal_only< T > const &rhs)

Typedef Documentation

◆ fix_int16

typedef fix_int<int16_t> msgpack::type::fix_int16

◆ fix_int32

typedef fix_int<int32_t> msgpack::type::fix_int32

◆ fix_int64

typedef fix_int<int64_t> msgpack::type::fix_int64

◆ fix_int8

typedef fix_int<int8_t> msgpack::type::fix_int8

◆ fix_uint16

typedef fix_int<uint16_t> msgpack::type::fix_uint16

◆ fix_uint32

typedef fix_int<uint32_t> msgpack::type::fix_uint32

◆ fix_uint64

typedef fix_int<uint64_t> msgpack::type::fix_uint64

◆ fix_uint8

typedef fix_int<uint8_t> msgpack::type::fix_uint8

◆ nil

typedef nil_t msgpack::type::nil

◆ variant

typedef basic_variant< std::string, std::vector< char >, msgpack::type::ext > msgpack::type::variant

◆ variant_ref

typedef basic_variant< std::string, msgpack::type::raw_ref, msgpack::type::ext_ref > msgpack::type::variant_ref

Enumeration Type Documentation

◆ object_type

enum msgpack::type::object_type
Enumerator
NIL 
BOOLEAN 
POSITIVE_INTEGER 
NEGATIVE_INTEGER 
FLOAT32 
FLOAT64 
FLOAT 
STR 
BIN 
ARRAY 
MAP 
EXT 

Function Documentation

◆ convert_helper() [1/2]

template<typename T>
std::enable_if<!has_as< T >::value >::type msgpack::type::convert_helper ( msgpack::object const & o,
T & t )
inline

References msgpack::object::convert().

◆ convert_helper() [2/2]

template<typename T>
std::enable_if< has_as< T >::value >::type msgpack::type::convert_helper ( msgpack::object const & o,
T & t )
inline

References msgpack::object::as().

Referenced by msgpack::type::define_array_imp< Tuple, N >::unpack(), msgpack::type::define_array_imp< Tuple, 1 >::unpack(), and msgpack::type::define_map_imp< Tuple, N >::unpack().

◆ forward_as_tuple()

template<class... Args>
tuple< Args &&... > msgpack::type::forward_as_tuple ( Args &&... args)
inlinenoexcept

◆ make_array_ref() [1/4]

template<typename T>
msgpack::enable_if<!msgpack::is_array< Tconst >::value, array_ref< Tconst > >::type msgpack::type::make_array_ref ( const T & t)
inline

◆ make_array_ref() [2/4]

template<typename T, std::size_t N>
array_ref< const T[N]> msgpack::type::make_array_ref ( const T(&) t[N])
inline

◆ make_array_ref() [3/4]

template<typename T>
msgpack::enable_if<!msgpack::is_array< T >::value, array_ref< T > >::type msgpack::type::make_array_ref ( T & t)
inline

◆ make_array_ref() [4/4]

template<typename T, std::size_t N>
array_ref< T[N]> msgpack::type::make_array_ref ( T(&) t[N])
inline

◆ make_define_array() [1/2]

define_array msgpack::type::make_define_array ( )
inline

◆ make_define_array() [2/2]

template<typename... Args>
define_array< Args... > msgpack::type::make_define_array ( Args &... args)
inline

◆ make_define_map() [1/2]

define_map msgpack::type::make_define_map ( )
inline

◆ make_define_map() [2/2]

template<typename... Args>
define_map< Args... > msgpack::type::make_define_map ( Args &... args)
inline

◆ make_size_equal_only()

template<typename T>
size_equal_only< T > msgpack::type::make_size_equal_only ( T & t)
inline

◆ make_tuple() [1/2]

tuple msgpack::type::make_tuple ( )
inline

Referenced by msgpack::MsgpackTupleAsImpl< T, Args >::as().

◆ make_tuple() [2/2]

template<class... Args>
tuple< Args... > msgpack::type::make_tuple ( Args &&... args)
inline

◆ operator!=()

template<typename STR, typename BIN, typename EXT>
bool msgpack::type::operator!= ( basic_variant< STR, BIN, EXT > const & lhs,
basic_variant< STR, BIN, EXT > const & rhs )

◆ operator<() [1/3]

template<typename STR, typename BIN, typename EXT>
bool msgpack::type::operator< ( basic_variant< STR, BIN, EXT > const & lhs,
basic_variant< STR, BIN, EXT > const & rhs )
inline

◆ operator<() [2/3]

bool msgpack::type::operator< ( nil_t const & lhs,
nil_t const & rhs )
inline

◆ operator<() [3/3]

template<typename T>
bool msgpack::type::operator< ( size_equal_only< T > const & lhs,
size_equal_only< T > const & rhs )
inline

References msgpack::type::size_equal_only< T >::m_t.

◆ operator==() [1/3]

template<typename STR, typename BIN, typename EXT>
bool msgpack::type::operator== ( basic_variant< STR, BIN, EXT > const & lhs,
basic_variant< STR, BIN, EXT > const & rhs )
inline

◆ operator==() [2/3]

bool msgpack::type::operator== ( nil_t const & lhs,
nil_t const & rhs )
inline

◆ operator==() [3/3]

template<typename T>
bool msgpack::type::operator== ( size_equal_only< T > const & lhs,
size_equal_only< T > const & rhs )
inline

References msgpack::type::size_equal_only< T >::m_t.

◆ size() [1/3]

template<typename T, std::size_t N>
std::size_t msgpack::type::size ( const T(&)[N])
inline

◆ size() [2/3]

template<typename... T>
std::size_t msgpack::type::size ( std::tuple< T... > const & )
inline

◆ size() [3/3]

template<typename T>
std::size_t msgpack::type::size ( T const & t)
inline

Referenced by msgpack::adaptor::convert< type::size_equal_only< T > >::operator()(), msgpack::type::define_array_imp< Tuple, N >::unpack(), and msgpack::type::define_array_imp< Tuple, 1 >::unpack().

◆ tie()

template<class... Args>
tuple< Args &... > msgpack::type::tie ( Args &... args)
inline

◆ tuple_cat()

template<class... Tuples>
auto msgpack::type::tuple_cat ( Tuples &&... args) ->decltype(std::tuple_cat(std::forward< typenamestd::remove_reference< Tuples >::type::base >(args)...))
inline

Referenced by msgpack::MsgpackTupleAsImpl< T, Args >::as().

Generated by doxygen 1.15.0