generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-24 09:12:30 +02:00
Code Issues Projects Releases Wiki Activity

Re-organized tree to prepare for version 2.0.0.

Browse Source 
See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_versioning
This commit is contained in:
Takatoshi Kondo
2016-01-22 21:44:58 +09:00
parent cabd8a8a03
commit 54cb4350b3
222 changed files with 16017 additions and 10672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
include/msgpack/v1/adaptor/cpp11/array.hpp Normal file
View File

@@ -0,0 +1,138 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_ARRAY_HPP
#define MSGPACK_V1_TYPE_CPP11_ARRAY_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include "msgpack/meta.hpp"
#include <array>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
namespace detail {
namespace array {
template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2>
inline std::array<T, N1+N2> concat(
std::array<T, N1>&& a1,
std::array<T, N2>&& a2,
msgpack::seq<I1...>,
msgpack::seq<I2...>) {
return {{ std::move(a1[I1])..., std::move(a2[I2])... }};
}
template<typename T, std::size_t N1, std::size_t N2>
inline std::array<T, N1+N2> concat(std::array<T, N1>&& a1, std::array<T, N2>&& a2) {
return concat(std::move(a1), std::move(a2), msgpack::gen_seq<N1>(), msgpack::gen_seq<N2>());
}
template <typename T, std::size_t N>
struct as_impl {
static std::array<T, N> as(msgpack::object const& o) {
msgpack::object* p = o.via.array.ptr + N - 1;
return concat(as_impl<T, N-1>::as(o), std::array<T, 1>{{p->as<T>()}});
}
};
template <typename T>
struct as_impl<T, 1> {
static std::array<T, 1> as(msgpack::object const& o) {
msgpack::object* p = o.via.array.ptr;
return std::array<T, 1>{{p->as<T>()}};
}
};
template <typename T>
struct as_impl<T, 0> {
static std::array<T, 0> as(msgpack::object const&) {
return std::array<T, 0>();
}
};
} // namespace array
} // namespace detail
template <typename T, std::size_t N>
struct as<std::array<T, N>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
std::array<T, N> operator()(msgpack::object const& o) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
if(o.via.array.size != N) { throw msgpack::type_error(); }
return detail::array::as_impl<T, N>::as(o);
}
};
template <typename T, std::size_t N>
struct convert<std::array<T, N>> {
msgpack::object const& operator()(msgpack::object const& o, std::array<T, N>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
if(o.via.array.size != N) { throw msgpack::type_error(); }
if(o.via.array.size > 0) {
msgpack::object* p = o.via.array.ptr;
msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
T* it = &v[0];
do {
p->convert(*it);
++p;
++it;
} while(p < pend);
}
return o;
}
};
template <typename T, std::size_t N>
struct pack<std::array<T, N>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<T, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_array(size);
for(auto const& e : v) o.pack(e);
return o;
}
};
template <typename T, std::size_t N>
struct object_with_zone<std::array<T, N>> {
void operator()(msgpack::object::with_zone& o, const std::array<T, N>& v) const {
o.type = msgpack::type::ARRAY;
if(v.empty()) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
o.via.array.size = size;
o.via.array.ptr = p;
for (auto const& e : v) *p++ = msgpack::object(e, o.zone);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_ARRAY_HPP

90
include/msgpack/v1/adaptor/cpp11/array_char.hpp Normal file
View File

@@ -0,0 +1,90 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_ARRAY_CHAR_HPP
#define MSGPACK_V1_TYPE_CPP11_ARRAY_CHAR_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <array>
#include <cstring>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <std::size_t N>
struct convert<std::array<char, N>> {
msgpack::object const& operator()(msgpack::object const& o, std::array<char, N>& v) const {
switch (o.type) {
case msgpack::type::BIN:
if(o.via.bin.size != N) { throw msgpack::type_error(); }
std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
break;
case msgpack::type::STR:
if(o.via.str.size != N) { throw msgpack::type_error(); }
std::memcpy(v.data(), o.via.str.ptr, N);
break;
default:
throw msgpack::type_error();
break;
}
return o;
}
};
template <std::size_t N>
struct pack<std::array<char, N>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_bin(size);
o.pack_bin_body(v.data(), size);
return o;
}
};
template <std::size_t N>
struct object<std::array<char, N>> {
void operator()(msgpack::object& o, const std::array<char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
o.via.bin.ptr = v.data();
o.via.bin.size = size;
}
};
template <std::size_t N>
struct object_with_zone<std::array<char, N>> {
void operator()(msgpack::object::with_zone& o, const std::array<char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
char* ptr = static_cast<char*>(o.zone.allocate_align(size));
o.via.bin.ptr = ptr;
o.via.bin.size = size;
std::memcpy(ptr, v.data(), size);
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_ARRAY_CHAR_HPP

90
include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp Normal file
View File

@@ -0,0 +1,90 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
#define MSGPACK_V1_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <array>
#include <cstring>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <std::size_t N>
struct convert<std::array<unsigned char, N>> {
msgpack::object const& operator()(msgpack::object const& o, std::array<unsigned char, N>& v) const {
switch (o.type) {
case msgpack::type::BIN:
if(o.via.bin.size != N) { throw msgpack::type_error(); }
std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
break;
case msgpack::type::STR:
if(o.via.str.size != N) { throw msgpack::type_error(); }
std::memcpy(v.data(), o.via.str.ptr, N);
break;
default:
throw msgpack::type_error();
break;
}
return o;
}
};
template <std::size_t N>
struct pack<std::array<unsigned char, N>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<unsigned char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_bin(size);
o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size);
return o;
}
};
template <std::size_t N>
struct object<std::array<unsigned char, N>> {
void operator()(msgpack::object& o, const std::array<unsigned char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
o.via.bin.ptr = reinterpret_cast<char const*>(v.data());
o.via.bin.size = size;
}
};
template <std::size_t N>
struct object_with_zone<std::array<unsigned char, N>> {
void operator()(msgpack::object::with_zone& o, const std::array<unsigned char, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
char* ptr = static_cast<char*>(o.zone.allocate_align(size));
o.via.bin.ptr = ptr;
o.via.bin.size = size;
std::memcpy(ptr, v.data(), size);
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP

94
include/msgpack/v1/adaptor/cpp11/forward_list.hpp Normal file
View File

@@ -0,0 +1,94 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014 KONDO-2015 Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_FORWARD_LIST_HPP
#define MSGPACK_V1_TYPE_CPP11_FORWARD_LIST_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <forward_list>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename T, typename Alloc>
struct as<std::forward_list<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
std::forward_list<T, Alloc> operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
std::forward_list<T, Alloc> v;
msgpack::object* p = o.via.array.ptr + o.via.array.size;
msgpack::object* const pend = o.via.array.ptr;
while (p != pend) {
--p;
v.push_front(p->as<T>());
}
return v;
}
};
template <typename T, typename Alloc>
struct convert<std::forward_list<T, Alloc>> {
msgpack::object const& operator()(msgpack::object const& o, std::forward_list<T, Alloc>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
v.resize(o.via.array.size);
msgpack::object* p = o.via.array.ptr;
for (auto &e : v) {
p->convert(e);
++p;
}
return o;
}
};
template <typename T, typename Alloc>
struct pack<std::forward_list<T, Alloc>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::forward_list<T, Alloc>& v) const {
uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
o.pack_array(size);
for(auto const& e : v) o.pack(e);
return o;
}
};
template <typename T, typename Alloc>
struct object_with_zone<std::forward_list<T, Alloc>> {
void operator()(msgpack::object::with_zone& o, const std::forward_list<T, Alloc>& v) const {
o.type = msgpack::type::ARRAY;
if(v.empty()) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
o.via.array.size = size;
msgpack::object* p = static_cast<msgpack::object*>(
o.zone.allocate_align(sizeof(msgpack::object)*size));
o.via.array.ptr = p;
for(auto const& e : v) *p++ = msgpack::object(e, o.zone);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_FORWARD_LIST_HPP

68
include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp Normal file
View File

@@ -0,0 +1,68 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_REFERENCE_WRAPPER_HPP
#define MSGPACK_V1_TYPE_CPP11_REFERENCE_WRAPPER_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <memory>
#include <type_traits>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename T>
struct convert<std::reference_wrapper<T>> {
msgpack::object const& operator()(msgpack::object const& o, std::reference_wrapper<T>& v) const {
msgpack::adaptor::convert<T>()(o, v.get());
return o;
}
};
template <typename T>
struct pack<std::reference_wrapper<T>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::reference_wrapper<T>& v) const {
o.pack(v.get());
return o;
}
};
template <typename T>
struct object<std::reference_wrapper<T> > {
void operator()(msgpack::object& o, const std::reference_wrapper<T>& v) const {
msgpack::adaptor::object<typename std::remove_const<T>::type>()(o, v.get());
}
};
template <typename T>
struct object_with_zone<std::reference_wrapper<T>> {
void operator()(msgpack::object::with_zone& o, const std::reference_wrapper<T>& v) const {
msgpack::adaptor::object_with_zone<typename std::remove_const<T>::type>()(o, v.get());
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_REFERENCE_WRAPPER_HPP

82
include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp Normal file
View File

@@ -0,0 +1,82 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_SHARED_PTR_HPP
#define MSGPACK_V1_TYPE_CPP11_SHARED_PTR_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <memory>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename T>
struct as<std::shared_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
std::shared_ptr<T> operator()(msgpack::object const& o) const {
if(o.is_nil()) return nullptr;
return std::make_shared<T>(o.as<T>());
}
};
template <typename T>
struct convert<std::shared_ptr<T>> {
msgpack::object const& operator()(msgpack::object const& o, std::shared_ptr<T>& v) const {
if(o.is_nil()) v.reset();
else {
v = std::make_shared<T>();
msgpack::adaptor::convert<T>()(o, *v);
}
return o;
}
};
template <typename T>
struct pack<std::shared_ptr<T>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::shared_ptr<T>& v) const {
if (v) o.pack(*v);
else o.pack_nil();
return o;
}
};
template <typename T>
struct object<std::shared_ptr<T> > {
void operator()(msgpack::object& o, const std::shared_ptr<T>& v) const {
if (v) msgpack::adaptor::object<T>()(o, *v);
else o.type = msgpack::type::NIL;
}
};
template <typename T>
struct object_with_zone<std::shared_ptr<T>> {
void operator()(msgpack::object::with_zone& o, const std::shared_ptr<T>& v) const {
if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
else o.type = msgpack::type::NIL;
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_SHARED_PTR_HPP

176
include/msgpack/v1/adaptor/cpp11/tuple.hpp Normal file
View File

@@ -0,0 +1,176 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_TUPLE_HPP
#define MSGPACK_V1_TYPE_CPP11_TUPLE_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include "msgpack/meta.hpp"
#include <tuple>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
// --- Pack from tuple to packer stream ---
template <typename Stream, typename Tuple, std::size_t N>
struct StdTuplePacker {
static void pack(
msgpack::packer<Stream>& o,
const Tuple& v) {
StdTuplePacker<Stream, Tuple, N-1>::pack(o, v);
o.pack(std::get<N-1>(v));
}
};
template <typename Stream, typename Tuple>
struct StdTuplePacker<Stream, Tuple, 0> {
static void pack (
msgpack::packer<Stream>&,
const Tuple&) {
}
};
namespace adaptor {
template <typename... Args>
struct pack<std::tuple<Args...>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(
msgpack::packer<Stream>& o,
const std::tuple<Args...>& v) const {
uint32_t size = checked_get_container_size(sizeof...(Args));
o.pack_array(size);
StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
return o;
}
};
} // namespace adaptor
// --- Convert from tuple to object ---
template <typename... Args>
struct StdTupleAs;
template <typename T, typename... Args>
struct StdTupleAsImpl {
static std::tuple<T, Args...> as(msgpack::object const& o) {
return std::tuple_cat(
std::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
StdTupleAs<Args...>::as(o));
}
};
template <typename... Args>
struct StdTupleAs {
static std::tuple<Args...> as(msgpack::object const& o) {
return StdTupleAsImpl<Args...>::as(o);
}
};
template <>
struct StdTupleAs<> {
static std::tuple<> as (msgpack::object const&) {
return std::tuple<>();
}
};
template <typename Tuple, std::size_t N>
struct StdTupleConverter {
static void convert(
msgpack::object const& o,
Tuple& v) {
StdTupleConverter<Tuple, N-1>::convert(o, v);
o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v));
}
};
template <typename Tuple>
struct StdTupleConverter<Tuple, 0> {
static void convert (
msgpack::object const&,
Tuple&) {
}
};
namespace adaptor {
template <typename... Args>
struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type> {
std::tuple<Args...> operator()(
msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
return StdTupleAs<Args...>::as(o);
}
};
template <typename... Args>
struct convert<std::tuple<Args...>> {
msgpack::object const& operator()(
msgpack::object const& o,
std::tuple<Args...>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
return o;
}
};
} // namespace adaptor
// --- Convert from tuple to object with zone ---
template <typename Tuple, std::size_t N>
struct StdTupleToObjectWithZone {
static void convert(
msgpack::object::with_zone& o,
const Tuple& v) {
StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
o.via.array.ptr[N-1] = msgpack::object(std::get<N-1>(v), o.zone);
}
};
template <typename Tuple>
struct StdTupleToObjectWithZone<Tuple, 0> {
static void convert (
msgpack::object::with_zone&,
const Tuple&) {
}
};
namespace adaptor {
template <typename... Args>
struct object_with_zone<std::tuple<Args...>> {
void operator()(
msgpack::object::with_zone& o,
std::tuple<Args...> const& v) const {
uint32_t size = checked_get_container_size(sizeof...(Args));
o.type = msgpack::type::ARRAY;
o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
o.via.array.size = size;
StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_TUPLE_HPP

82
include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp Normal file
View File

@@ -0,0 +1,82 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_UNIQUE_PTR_HPP
#define MSGPACK_V1_TYPE_CPP11_UNIQUE_PTR_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <memory>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename T>
struct as<std::unique_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
std::unique_ptr<T> operator()(msgpack::object const& o) const {
if(o.is_nil()) return nullptr;
return std::unique_ptr<T>(new T(o.as<T>()));
}
};
template <typename T>
struct convert<std::unique_ptr<T>> {
msgpack::object const& operator()(msgpack::object const& o, std::unique_ptr<T>& v) const {
if(o.is_nil()) v.reset();
else {
v.reset(new T);
msgpack::adaptor::convert<T>()(o, *v);
}
return o;
}
};
template <typename T>
struct pack<std::unique_ptr<T>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unique_ptr<T>& v) const {
if (v) o.pack(*v);
else o.pack_nil();
return o;
}
};
template <typename T>
struct object<std::unique_ptr<T> > {
void operator()(msgpack::object& o, const std::unique_ptr<T>& v) const {
if (v) msgpack::adaptor::object<T>()(o, *v);
else o.type = msgpack::type::NIL;
}
};
template <typename T>
struct object_with_zone<std::unique_ptr<T>> {
void operator()(msgpack::object::with_zone& o, const std::unique_ptr<T>& v) const {
if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
else o.type = msgpack::type::NIL;
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_UNIQUE_PTR_HPP

182
include/msgpack/v1/adaptor/cpp11/unordered_map.hpp Normal file
View File

@@ -0,0 +1,182 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_UNORDERED_MAP_HPP
#define MSGPACK_V1_TYPE_CPP11_UNORDERED_MAP_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <unordered_map>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct as<
std::unordered_map<K, V, Hash, Compare, Alloc>,
typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
std::unordered_map<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
msgpack::object_kv* p(o.via.map.ptr);
msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
std::unordered_map<K, V, Hash, Compare, Alloc> v;
for (; p != pend; ++p) {
v.emplace(p->key.as<K>(), p->val.as<V>());
}
return v;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct convert<std::unordered_map<K, V, Hash, Compare, Alloc>> {
msgpack::object const& operator()(msgpack::object const& o, std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
msgpack::object_kv* p(o.via.map.ptr);
msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
std::unordered_map<K, V, Hash, Compare, Alloc> tmp;
for(; p != pend; ++p) {
K key;
p->key.convert(key);
p->val.convert(tmp[std::move(key)]);
}
v = std::move(tmp);
return o;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_map(size);
for(typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) {
o.pack(it->first);
o.pack(it->second);
}
return o;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
void operator()(msgpack::object::with_zone& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
o.type = msgpack::type::MAP;
if(v.empty()) {
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
msgpack::object_kv* const pend = p + size;
o.via.map.ptr = p;
o.via.map.size = size;
typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
do {
p->key = msgpack::object(it->first, o.zone);
p->val = msgpack::object(it->second, o.zone);
++p;
++it;
} while(p < pend);
}
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct as<
std::unordered_multimap<K, V, Hash, Compare, Alloc>,
typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
std::unordered_multimap<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
msgpack::object_kv* p(o.via.map.ptr);
msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
std::unordered_multimap<K, V, Hash, Compare, Alloc> v;
for (; p != pend; ++p) {
v.emplace(p->key.as<K>(), p->val.as<V>());
}
return v;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct convert<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
msgpack::object_kv* p(o.via.map.ptr);
msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
std::unordered_multimap<K, V, Hash, Compare, Alloc> tmp;
for(; p != pend; ++p) {
std::pair<K, V> value;
p->key.convert(value.first);
p->val.convert(value.second);
tmp.insert(std::move(value));
}
v = std::move(tmp);
return o;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_map(size);
for(typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) {
o.pack(it->first);
o.pack(it->second);
}
return o;
}
};
template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
void operator()(msgpack::object::with_zone& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
o.type = msgpack::type::MAP;
if(v.empty()) {
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
msgpack::object_kv* const pend = p + size;
o.via.map.ptr = p;
o.via.map.size = size;
typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
do {
p->key = msgpack::object(it->first, o.zone);
p->val = msgpack::object(it->second, o.zone);
++p;
++it;
} while(p < pend);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_UNORDERED_MAP_HPP

172
include/msgpack/v1/adaptor/cpp11/unordered_set.hpp Normal file
View File

@@ -0,0 +1,172 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2014-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_TYPE_CPP11_UNORDERED_SET_HPP
#define MSGPACK_V1_TYPE_CPP11_UNORDERED_SET_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <unordered_set>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
std::unordered_set<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
msgpack::object* p = o.via.array.ptr + o.via.array.size;
msgpack::object* const pbegin = o.via.array.ptr;
std::unordered_set<Key, Hash, Compare, Alloc> v;
while (p > pbegin) {
--p;
v.insert(p->as<Key>());
}
return v;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> {
msgpack::object const& operator()(msgpack::object const& o, std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
msgpack::object* p = o.via.array.ptr + o.via.array.size;
msgpack::object* const pbegin = o.via.array.ptr;
std::unordered_set<Key, Hash, Compare, Alloc> tmp;
while(p > pbegin) {
--p;
tmp.insert(p->as<Key>());
}
v = std::move(tmp);
return o;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct pack<std::unordered_set<Key, Hash, Compare, Alloc>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_array(size);
for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) {
o.pack(*it);
}
return o;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
void operator()(msgpack::object::with_zone& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
o.type = msgpack::type::ARRAY;
if(v.empty()) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
msgpack::object* const pend = p + size;
o.via.array.ptr = p;
o.via.array.size = size;
typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
do {
*p = msgpack::object(*it, o.zone);
++p;
++it;
} while(p < pend);
}
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
std::unordered_multiset<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
msgpack::object* p = o.via.array.ptr + o.via.array.size;
msgpack::object* const pbegin = o.via.array.ptr;
std::unordered_multiset<Key, Hash, Compare, Alloc> v;
while (p > pbegin) {
--p;
v.insert(p->as<Key>());
}
return v;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
msgpack::object* p = o.via.array.ptr + o.via.array.size;
msgpack::object* const pbegin = o.via.array.ptr;
std::unordered_multiset<Key, Hash, Compare, Alloc> tmp;
while(p > pbegin) {
--p;
tmp.insert(p->as<Key>());
}
v = std::move(tmp);
return o;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct pack<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_array(size);
for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) {
o.pack(*it);
}
return o;
}
};
template <typename Key, typename Hash, typename Compare, typename Alloc>
struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
void operator()(msgpack::object::with_zone& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
o.type = msgpack::type::ARRAY;
if(v.empty()) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
msgpack::object* const pend = p + size;
o.via.array.ptr = p;
o.via.array.size = size;
typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
do {
*p = msgpack::object(*it, o.zone);
++p;
++it;
} while(p < pend);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_TYPE_CPP11_UNORDERED_SET_HPP