mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-06-25 22:15:23 +02:00
remove C++ part files
remove the following files or folders: erb example/boost example/cpp03 example/cpp11 example/x3 example/CMakeLists.txt fuzz include/msgpack/adaptor include/msgpack/predef.h include/msgpack/predef include/msgpack/preprocessor include/msgpack/v1 include/msgpack/v2 include/msgpack/v3 include/msgpack/*.hpp include/msgpack.hpp .gitmodules external make_file_list.sh msgpack_vc8.sln msgpack_vc8.vcproj preprocess QUICKSTART-CPP.md test/*.cpp exclude test/*_c.cpp .github/depends/boost.sh ci/build_regression.sh
This commit is contained in:
yuangongji
parent
6e7deb8091
commit
ee546036a1
56
.github/depends/boost.sh
vendored
56
.github/depends/boost.sh
vendored
@ -1,56 +0,0 @@
|
||||
#!/bin/sh
|
||||
|
||||
usage()
|
||||
{
|
||||
cat <<EOL
|
||||
-b - 32-bit or 64-bit library, maybe 32, 64 or both
|
||||
-t - the toolset, maybe gcc, clang or both
|
||||
EOL
|
||||
}
|
||||
|
||||
build_boost()
|
||||
{
|
||||
BASE=`pwd`/..
|
||||
./b2 -j4 --toolset=$1 --prefix=${BASE}/usr --libdir="${BASE}/usr/$1/lib$2" --with-chrono --with-context --with-filesystem --with-system --with-timer address-model=$2 install
|
||||
}
|
||||
|
||||
bit="64"
|
||||
toolset="gcc"
|
||||
|
||||
while getopts "b:t:" c; do
|
||||
case "$c" in
|
||||
b)
|
||||
bit="$OPTARG"
|
||||
[ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
|
||||
;;
|
||||
t)
|
||||
toolset="$OPTARG"
|
||||
[ "$toolset" != "gcc" ] && [ "$toolset" != "clang" ] && [ "$toolset" != "both" ] && usage && exit 1
|
||||
;;
|
||||
?*)
|
||||
echo "invalid arguments." && exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
wget https://dl.bintray.com/boostorg/release/1.71.0/source/boost_1_71_0.tar.bz2
|
||||
tar xf boost_1_71_0.tar.bz2
|
||||
cd boost_1_71_0
|
||||
./bootstrap.sh
|
||||
|
||||
build()
|
||||
{
|
||||
if [ "$bit" = "both" ]; then
|
||||
build_boost $1 32
|
||||
build_boost $1 64
|
||||
else
|
||||
build_boost $1 $bit
|
||||
fi
|
||||
}
|
||||
|
||||
if [ "$toolset" = "both" ]; then
|
||||
build gcc
|
||||
build clang
|
||||
else
|
||||
build $toolset
|
||||
fi
|
||||
6
.gitmodules
vendored
6
.gitmodules
vendored
@ -1,6 +0,0 @@
|
||||
[submodule "external/boost/predef"]
|
||||
path = external/boost/predef
|
||||
url = https://github.com/boostorg/predef.git
|
||||
[submodule "external/boost/preprocessor"]
|
||||
path = external/boost/preprocessor
|
||||
url = https://github.com/boostorg/preprocessor.git
|
||||
@ -1,159 +0,0 @@
|
||||
# Implementation Status
|
||||
|
||||
The serialization library is production-ready.
|
||||
|
||||
Currently, RPC implementation is in testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
|
||||
|
||||
# Install
|
||||
|
||||
Same as QuickStart for C Language.
|
||||
|
||||
# Serialization QuickStart for C+\+
|
||||
|
||||
## First program
|
||||
|
||||
Include `msgpack.hpp` header and link `msgpack` library to use MessagePack on your program.
|
||||
|
||||
```cpp
|
||||
#include <msgpack.hpp>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
int main(void) {
|
||||
// serializes this object.
|
||||
std::vector<std::string> vec;
|
||||
vec.push_back("Hello");
|
||||
vec.push_back("MessagePack");
|
||||
|
||||
// serialize it into simple buffer.
|
||||
msgpack::sbuffer sbuf;
|
||||
msgpack::pack(sbuf, vec);
|
||||
|
||||
// deserialize it.
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(sbuf.data(), sbuf.size());
|
||||
|
||||
// print the deserialized object.
|
||||
msgpack::object obj = oh.get();
|
||||
std::cout << obj << std::endl; //=> ["Hello", "MessagePack"]
|
||||
|
||||
// convert it into statically typed object.
|
||||
std::vector<std::string> rvec;
|
||||
obj.convert(rvec);
|
||||
}
|
||||
```
|
||||
|
||||
Compile it as follows:
|
||||
|
||||
```
|
||||
$ g++ -Ipath_to_msgpack/include hello.cc -o hello
|
||||
$ ./hello
|
||||
["Hello", "MessagePack"]
|
||||
```
|
||||
|
||||
## Streaming feature
|
||||
|
||||
```cpp
|
||||
#include <msgpack.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
int main() {
|
||||
// serializes multiple objects using msgpack::packer.
|
||||
msgpack::sbuffer buffer;
|
||||
|
||||
msgpack::packer<msgpack::sbuffer> pk(&buffer);
|
||||
pk.pack(std::string("Log message ... 1"));
|
||||
pk.pack(std::string("Log message ... 2"));
|
||||
pk.pack(std::string("Log message ... 3"));
|
||||
|
||||
// deserializes these objects using msgpack::unpacker.
|
||||
msgpack::unpacker pac;
|
||||
|
||||
// feeds the buffer.
|
||||
pac.reserve_buffer(buffer.size());
|
||||
memcpy(pac.buffer(), buffer.data(), buffer.size());
|
||||
pac.buffer_consumed(buffer.size());
|
||||
|
||||
// now starts streaming deserialization.
|
||||
msgpack::object_handle oh;
|
||||
while(pac.next(oh)) {
|
||||
std::cout << oh.get() << std::endl;
|
||||
}
|
||||
|
||||
// results:
|
||||
// $ g++ -Ipath_to_msgpack/include stream.cc -o stream
|
||||
// $ ./stream
|
||||
// "Log message ... 1"
|
||||
// "Log message ... 2"
|
||||
// "Log message ... 3"
|
||||
}
|
||||
```
|
||||
|
||||
### Streaming into an array or map
|
||||
|
||||
```cpp
|
||||
#include <msgpack.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
int main() {
|
||||
// serializes multiple objects into one message containing an array using msgpack::packer.
|
||||
msgpack::sbuffer buffer;
|
||||
|
||||
msgpack::packer<msgpack::sbuffer> pk(&buffer);
|
||||
pk.pack_array(3);
|
||||
pk.pack(std::string("Log message ... 1"));
|
||||
pk.pack(std::string("Log message ... 2"));
|
||||
pk.pack(std::string("Log message ... 3"));
|
||||
|
||||
// serializes multiple objects into one message containing a map using msgpack::packer.
|
||||
msgpack::sbuffer buffer2;
|
||||
|
||||
msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
|
||||
pk2.pack_map(2);
|
||||
pk2.pack(std::string("x"));
|
||||
pk2.pack(3);
|
||||
pk2.pack(std::string("y"));
|
||||
pk2.pack(3.4321);
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## User-defined classes
|
||||
|
||||
You can use serialize/deserializes user-defined classes using `MSGPACK_DEFINE` macro.
|
||||
|
||||
```cpp
|
||||
#include <msgpack.hpp>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
class myclass {
|
||||
private:
|
||||
std::string m_str;
|
||||
std::vector<int> m_vec;
|
||||
public:
|
||||
MSGPACK_DEFINE(m_str, m_vec);
|
||||
};
|
||||
|
||||
int main() {
|
||||
std::vector<myclass> vec;
|
||||
// add some elements into vec...
|
||||
|
||||
// you can serialize myclass directly
|
||||
msgpack::sbuffer sbuf;
|
||||
msgpack::pack(sbuf, vec);
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(sbuf.data(), sbuf.size());
|
||||
|
||||
msgpack::object obj = oh.get();
|
||||
|
||||
// you can convert object to myclass directly
|
||||
std::vector<myclass> rvec;
|
||||
obj.convert(rvec);
|
||||
}
|
||||
```
|
||||
@ -1,49 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
mkdir -p build
|
||||
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]
|
||||
then
|
||||
exit $ret
|
||||
fi
|
||||
|
||||
cd build
|
||||
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]
|
||||
then
|
||||
exit $ret
|
||||
fi
|
||||
|
||||
if [ "${ARCH}" == "32" ]
|
||||
then
|
||||
echo "64 bit support required for regressions"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
cmake -DMSGPACK_FUZZ_REGRESSION="ON" -DMSGPACK_CXX11="ON" -DMSGPACK_BOOST=${BOOST} -DMSGPACK_SAN=${MSGPACK_SAN} -v ..
|
||||
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]
|
||||
then
|
||||
exit $ret
|
||||
fi
|
||||
|
||||
make
|
||||
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]
|
||||
then
|
||||
exit $ret
|
||||
fi
|
||||
|
||||
make test
|
||||
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]
|
||||
then
|
||||
exit $ret
|
||||
fi
|
||||
|
||||
exit 0
|
||||
@ -1,110 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_DEFINE_ARRAY_HPP
|
||||
#define MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp"
|
||||
#include "msgpack/adaptor/msgpack_tuple.hpp"
|
||||
#include "msgpack/adaptor/adaptor_base.hpp"
|
||||
#include "msgpack/object_fwd.hpp"
|
||||
|
||||
namespace msgpack {
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
namespace type {
|
||||
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
template <>
|
||||
struct define_array<> {
|
||||
typedef define_array<> value_type;
|
||||
typedef tuple<> tuple_type;
|
||||
template <typename Packer>
|
||||
void msgpack_pack(Packer& pk) const
|
||||
{
|
||||
pk.pack_array(0);
|
||||
}
|
||||
void msgpack_unpack(msgpack::object const& o)
|
||||
{
|
||||
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
|
||||
}
|
||||
void msgpack_object(msgpack::object* o, msgpack::zone&) const
|
||||
{
|
||||
o->type = msgpack::type::ARRAY;
|
||||
o->via.array.ptr = MSGPACK_NULLPTR;
|
||||
o->via.array.size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
|
||||
typedef define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
|
||||
typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
|
||||
define_array(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
|
||||
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
|
||||
template <typename Packer>
|
||||
void msgpack_pack(Packer& pk) const
|
||||
{
|
||||
pk.pack_array(<%=i+1%>);
|
||||
<%0.upto(i) {|j|%>
|
||||
pk.pack(a<%=j%>);<%}%>
|
||||
}
|
||||
void msgpack_unpack(msgpack::object const& o)
|
||||
{
|
||||
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
|
||||
const size_t size = o.via.array.size;
|
||||
if(size > 0) {
|
||||
msgpack::object *ptr = o.via.array.ptr;
|
||||
switch(size) {
|
||||
default:<%(i).downto(0) {|j|%>
|
||||
case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);
|
||||
// fallthrough
|
||||
<%}%>
|
||||
}
|
||||
}
|
||||
}
|
||||
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
|
||||
{
|
||||
o->type = msgpack::type::ARRAY;
|
||||
o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
|
||||
o->via.array.size = <%=i+1%>;
|
||||
<%0.upto(i) {|j|%>
|
||||
o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>
|
||||
}
|
||||
<%0.upto(i) {|j|%>
|
||||
A<%=j%>& a<%=j%>;<%}%>
|
||||
};
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
inline define_array<> make_define_array()
|
||||
{
|
||||
return define_array<>();
|
||||
}
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
|
||||
{
|
||||
return define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
|
||||
}
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
|
||||
@ -1,42 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_DEFINE_ARRAY_DECL_HPP
|
||||
#define MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
|
||||
|
||||
#include "msgpack/versioning.hpp"
|
||||
|
||||
namespace msgpack {
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
namespace type {
|
||||
|
||||
/// @cond
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
|
||||
struct define_array;
|
||||
/// @endcond
|
||||
|
||||
define_array<> make_define_array();
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>);
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
|
||||
@ -1,120 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2015-2016 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_CPP03_DEFINE_MAP_HPP
|
||||
#define MSGPACK_V1_CPP03_DEFINE_MAP_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp"
|
||||
#include "msgpack/adaptor/msgpack_tuple.hpp"
|
||||
#include "msgpack/adaptor/adaptor_base.hpp"
|
||||
#include "msgpack/object_fwd.hpp"
|
||||
|
||||
#include <map>
|
||||
|
||||
namespace msgpack {
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
namespace type {
|
||||
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
template <>
|
||||
struct define_map<> {
|
||||
template <typename Packer>
|
||||
void msgpack_pack(Packer& pk) const
|
||||
{
|
||||
pk.pack_map(0);
|
||||
}
|
||||
void msgpack_unpack(msgpack::object const& o) const
|
||||
{
|
||||
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
|
||||
}
|
||||
void msgpack_object(msgpack::object* o, msgpack::zone&) const
|
||||
{
|
||||
o->type = msgpack::type::MAP;
|
||||
o->via.map.ptr = MSGPACK_NULLPTR;
|
||||
o->via.map.size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%1.step(GENERATION_LIMIT+1,2) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
|
||||
define_map(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
|
||||
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
|
||||
template <typename Packer>
|
||||
void msgpack_pack(Packer& pk) const
|
||||
{
|
||||
pk.pack_map(<%=(i+1)/2%>);
|
||||
<%0.upto(i) {|j|%>
|
||||
pk.pack(a<%=j%>);<%}%>
|
||||
}
|
||||
void msgpack_unpack(msgpack::object const& o) const
|
||||
{
|
||||
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
|
||||
std::map<std::string, msgpack::object const*> kvmap;
|
||||
for (uint32_t i = 0; i < o.via.map.size; ++i) {
|
||||
if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
|
||||
kvmap.insert(
|
||||
std::map<std::string, msgpack::object const*>::value_type(
|
||||
std::string(
|
||||
o.via.map.ptr[i].key.via.str.ptr,
|
||||
o.via.map.ptr[i].key.via.str.size),
|
||||
&o.via.map.ptr[i].val
|
||||
)
|
||||
);
|
||||
}
|
||||
<%0.step(i,2) {|j|%>
|
||||
{
|
||||
std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a<%=j%>);
|
||||
if (it != kvmap.end()) {
|
||||
it->second->convert(a<%=j+1%>);
|
||||
}
|
||||
}
|
||||
<%}%>
|
||||
}
|
||||
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
|
||||
{
|
||||
o->type = msgpack::type::MAP;
|
||||
o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
|
||||
o->via.map.size = <%=(i+1)/2%>;
|
||||
<%0.step(i,2) {|j|%>
|
||||
o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);
|
||||
o->via.map.ptr[<%=j/2%>].val = msgpack::object(a<%=j+1%>, z);
|
||||
<%}%>
|
||||
}
|
||||
<%0.upto(i) {|j|%>
|
||||
A<%=j%>& a<%=j%>;<%}%>
|
||||
};
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
inline define_map<> make_define_map()
|
||||
{
|
||||
return define_map<>();
|
||||
}
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
inline define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
|
||||
{
|
||||
return define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
|
||||
}
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_DEFINE_MAP_HPP
|
||||
@ -1,42 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2015-2016 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_CPP03_DEFINE_MAP_DECL_HPP
|
||||
#define MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
|
||||
|
||||
#include "msgpack/versioning.hpp"
|
||||
|
||||
namespace msgpack {
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
namespace type {
|
||||
|
||||
/// @cond
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
|
||||
struct define_map;
|
||||
/// @endcond
|
||||
|
||||
define_map<> make_define_map();
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>);
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
|
||||
@ -1,227 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_MSGPACK_TUPLE_HPP
|
||||
#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
|
||||
|
||||
namespace msgpack {
|
||||
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
|
||||
namespace type {
|
||||
|
||||
// FIXME operator==
|
||||
// FIXME operator!=
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
|
||||
template <typename T>
|
||||
struct tuple_type {
|
||||
typedef T type;
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef const T& transparent_reference;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct tuple_type<T&> {
|
||||
typedef T type;
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& transparent_reference;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct tuple_type<const T&> {
|
||||
typedef T type;
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef const T& transparent_reference;
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
<%0.upto(i) {|j|%>
|
||||
template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
|
||||
struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
|
||||
tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {}
|
||||
typename tuple_type<A<%=j%>>::reference get() { return m_x; }
|
||||
typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
|
||||
private:
|
||||
typename tuple_type<A<%=j%>>::reference m_x;
|
||||
};
|
||||
<%}%>
|
||||
<%}%>
|
||||
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
<%0.upto(i) {|j|%>
|
||||
template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
|
||||
struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
|
||||
const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {}
|
||||
typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
|
||||
private:
|
||||
typename tuple_type<A<%=j%>>::const_reference m_x;
|
||||
};
|
||||
<%}%>
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
template <>
|
||||
struct tuple<> {
|
||||
tuple() {}
|
||||
tuple(msgpack::object const& o) { o.convert(*this); }
|
||||
typedef tuple<> value_type;
|
||||
std::size_t size() const { return 0; }
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
|
||||
typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
|
||||
std::size_t size() const { return <%=i+1%>; }
|
||||
tuple() {}
|
||||
tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
|
||||
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
|
||||
tuple(msgpack::object const& o) { o.convert(*this); }
|
||||
template <int N> typename tuple_element<value_type, N>::reference get()
|
||||
{ return tuple_element<value_type, N>(*this).get(); }
|
||||
template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
|
||||
{ return const_tuple_element<value_type, N>(*this).get(); }
|
||||
<%0.upto(i) {|j|%>
|
||||
A<%=j%> a<%=j%>;<%}%>
|
||||
};
|
||||
|
||||
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
inline typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t)
|
||||
{ return t.template get<N>(); }
|
||||
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
inline typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t)
|
||||
{ return t.template get<N>(); }
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
inline tuple<> make_tuple()
|
||||
{
|
||||
return tuple<>();
|
||||
}
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>)
|
||||
{
|
||||
return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
|
||||
}
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
|
||||
namespace adaptor {
|
||||
|
||||
template <>
|
||||
struct convert<type::tuple<> > {
|
||||
msgpack::object const& operator()(
|
||||
msgpack::object const& o,
|
||||
type::tuple<>&) const {
|
||||
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
|
||||
msgpack::object const& operator()(
|
||||
msgpack::object const& o,
|
||||
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
|
||||
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
|
||||
<%0.upto(i) {|j|%>
|
||||
// In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
|
||||
if(o.via.array.size > <%=j%>)
|
||||
o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
|
||||
return o;
|
||||
}
|
||||
};
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
template <>
|
||||
struct pack<type::tuple<> > {
|
||||
template <typename Stream>
|
||||
msgpack::packer<Stream>& operator()(
|
||||
msgpack::packer<Stream>& o,
|
||||
const type::tuple<>&) const {
|
||||
o.pack_array(0);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct pack<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
|
||||
template <typename Stream>
|
||||
msgpack::packer<Stream>& operator()(
|
||||
msgpack::packer<Stream>& o,
|
||||
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
|
||||
o.pack_array(<%=i+1%>);
|
||||
<%0.upto(i) {|j|%>
|
||||
o.pack(v.template get<<%=j%>>());<%}%>
|
||||
return o;
|
||||
}
|
||||
};
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
template <>
|
||||
struct object_with_zone<type::tuple<> > {
|
||||
void operator()(
|
||||
msgpack::object::with_zone& o,
|
||||
const type::tuple<>&) const {
|
||||
o.type = msgpack::type::ARRAY;
|
||||
o.via.array.ptr = MSGPACK_NULLPTR;
|
||||
o.via.array.size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
|
||||
void operator()(
|
||||
msgpack::object::with_zone& o,
|
||||
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
|
||||
o.type = msgpack::type::ARRAY;
|
||||
o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
|
||||
o.via.array.size = <%=i+1%>;
|
||||
<%0.upto(i) {|j|%>
|
||||
o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>
|
||||
}
|
||||
};
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace adaptor
|
||||
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
|
||||
@ -1,69 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_MSGPACK_TUPLE_DECL_HPP
|
||||
#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
|
||||
|
||||
#include "msgpack/versioning.hpp"
|
||||
#include "msgpack/object.hpp"
|
||||
#include "msgpack/adaptor/adaptor_base.hpp"
|
||||
|
||||
namespace msgpack {
|
||||
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
|
||||
namespace type {
|
||||
|
||||
// FIXME operator==
|
||||
// FIXME operator!=
|
||||
<% GENERATION_LIMIT = 31 %>
|
||||
|
||||
/// @cond
|
||||
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
|
||||
struct tuple;
|
||||
/// @endcond
|
||||
|
||||
template <typename Tuple, int N>
|
||||
struct tuple_element;
|
||||
|
||||
template <typename Tuple, int N>
|
||||
struct const_tuple_element;
|
||||
|
||||
template <typename T>
|
||||
struct tuple_type;
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t);
|
||||
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t);
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
tuple<> make_tuple();
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>);
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
} // namespace type
|
||||
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
|
||||
@ -1,334 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ memory pool
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_ZONE_HPP
|
||||
#define MSGPACK_V1_CPP03_ZONE_HPP
|
||||
|
||||
#include "msgpack/zone_decl.hpp"
|
||||
|
||||
<% GENERATION_LIMIT = 15 %>
|
||||
namespace msgpack {
|
||||
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
|
||||
class zone {
|
||||
struct finalizer {
|
||||
finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
|
||||
void operator()() { m_func(m_data); }
|
||||
void (*m_func)(void*);
|
||||
void* m_data;
|
||||
};
|
||||
struct finalizer_array {
|
||||
finalizer_array():m_tail(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_NULLPTR) {}
|
||||
void call() {
|
||||
finalizer* fin = m_tail;
|
||||
for(; fin != m_array; --fin) (*(fin-1))();
|
||||
}
|
||||
~finalizer_array() {
|
||||
call();
|
||||
::free(m_array);
|
||||
}
|
||||
void clear() {
|
||||
call();
|
||||
m_tail = m_array;
|
||||
}
|
||||
void push(void (*func)(void* data), void* data)
|
||||
{
|
||||
finalizer* fin = m_tail;
|
||||
|
||||
if(fin == m_end) {
|
||||
push_expand(func, data);
|
||||
return;
|
||||
}
|
||||
|
||||
fin->m_func = func;
|
||||
fin->m_data = data;
|
||||
|
||||
++m_tail;
|
||||
}
|
||||
void push_expand(void (*func)(void*), void* data) {
|
||||
const size_t nused = static_cast<size_t>(m_end - m_array);
|
||||
size_t nnext;
|
||||
if(nused == 0) {
|
||||
nnext = (sizeof(finalizer) < 72/2) ?
|
||||
72 / sizeof(finalizer) : 8;
|
||||
} else {
|
||||
nnext = nused * 2;
|
||||
}
|
||||
finalizer* tmp =
|
||||
static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
|
||||
if(!tmp) {
|
||||
throw std::bad_alloc();
|
||||
}
|
||||
m_array = tmp;
|
||||
m_end = tmp + nnext;
|
||||
m_tail = tmp + nused;
|
||||
new (m_tail) finalizer(func, data);
|
||||
|
||||
++m_tail;
|
||||
}
|
||||
finalizer* m_tail;
|
||||
finalizer* m_end;
|
||||
finalizer* m_array;
|
||||
};
|
||||
struct chunk {
|
||||
chunk* m_next;
|
||||
};
|
||||
struct chunk_list {
|
||||
chunk_list(size_t chunk_size)
|
||||
{
|
||||
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
|
||||
if(!c) {
|
||||
throw std::bad_alloc();
|
||||
}
|
||||
|
||||
m_head = c;
|
||||
m_free = chunk_size;
|
||||
m_ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||
c->m_next = MSGPACK_NULLPTR;
|
||||
}
|
||||
~chunk_list()
|
||||
{
|
||||
chunk* c = m_head;
|
||||
while(c) {
|
||||
chunk* n = c->m_next;
|
||||
::free(c);
|
||||
c = n;
|
||||
}
|
||||
}
|
||||
void clear(size_t chunk_size)
|
||||
{
|
||||
chunk* c = m_head;
|
||||
while(true) {
|
||||
chunk* n = c->m_next;
|
||||
if(n) {
|
||||
::free(c);
|
||||
c = n;
|
||||
} else {
|
||||
m_head = c;
|
||||
break;
|
||||
}
|
||||
}
|
||||
m_head->m_next = MSGPACK_NULLPTR;
|
||||
m_free = chunk_size;
|
||||
m_ptr = reinterpret_cast<char*>(m_head) + sizeof(chunk);
|
||||
}
|
||||
size_t m_free;
|
||||
char* m_ptr;
|
||||
chunk* m_head;
|
||||
};
|
||||
size_t m_chunk_size;
|
||||
chunk_list m_chunk_list;
|
||||
finalizer_array m_finalizer_array;
|
||||
|
||||
public:
|
||||
zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */;
|
||||
|
||||
public:
|
||||
void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
|
||||
void* allocate_no_align(size_t size);
|
||||
|
||||
void push_finalizer(void (*func)(void*), void* data);
|
||||
|
||||
template <typename T>
|
||||
void push_finalizer(msgpack::unique_ptr<T> obj);
|
||||
|
||||
void clear();
|
||||
|
||||
void swap(zone& o);
|
||||
static void* operator new(std::size_t size)
|
||||
{
|
||||
void* p = ::malloc(size);
|
||||
if (!p) throw std::bad_alloc();
|
||||
return p;
|
||||
}
|
||||
static void operator delete(void *p) /* throw() */
|
||||
{
|
||||
::free(p);
|
||||
}
|
||||
static void* operator new(std::size_t size, void* place) /* throw() */
|
||||
{
|
||||
return ::operator new(size, place);
|
||||
}
|
||||
static void operator delete(void* p, void* place) /* throw() */
|
||||
{
|
||||
::operator delete(p, place);
|
||||
}
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
private:
|
||||
void undo_allocate(size_t size);
|
||||
|
||||
template <typename T>
|
||||
static void object_destruct(void* obj);
|
||||
|
||||
template <typename T>
|
||||
static void object_delete(void* obj);
|
||||
|
||||
static char* get_aligned(char* ptr, size_t align);
|
||||
|
||||
char* allocate_expand(size_t size);
|
||||
private:
|
||||
zone(const zone&);
|
||||
zone& operator=(const zone&);
|
||||
};
|
||||
|
||||
inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
|
||||
{
|
||||
}
|
||||
|
||||
inline char* zone::get_aligned(char* ptr, size_t align)
|
||||
{
|
||||
return
|
||||
reinterpret_cast<char*>(
|
||||
reinterpret_cast<size_t>(
|
||||
(ptr + (align - 1))) / align * align);
|
||||
}
|
||||
|
||||
inline void* zone::allocate_align(size_t size, size_t align)
|
||||
{
|
||||
char* aligned = get_aligned(m_chunk_list.m_ptr, align);
|
||||
size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
|
||||
if (m_chunk_list.m_free < adjusted_size) {
|
||||
size_t enough_size = size + align - 1;
|
||||
char* ptr = allocate_expand(enough_size);
|
||||
aligned = get_aligned(ptr, align);
|
||||
adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
|
||||
}
|
||||
m_chunk_list.m_free -= adjusted_size;
|
||||
m_chunk_list.m_ptr += adjusted_size;
|
||||
return aligned;
|
||||
}
|
||||
|
||||
inline void* zone::allocate_no_align(size_t size)
|
||||
{
|
||||
char* ptr = m_chunk_list.m_ptr;
|
||||
if(m_chunk_list.m_free < size) {
|
||||
ptr = allocate_expand(size);
|
||||
}
|
||||
m_chunk_list.m_free -= size;
|
||||
m_chunk_list.m_ptr += size;
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
inline char* zone::allocate_expand(size_t size)
|
||||
{
|
||||
chunk_list* const cl = &m_chunk_list;
|
||||
|
||||
size_t sz = m_chunk_size;
|
||||
|
||||
while(sz < size) {
|
||||
size_t tmp_sz = sz * 2;
|
||||
if (tmp_sz <= sz) {
|
||||
sz = size;
|
||||
break;
|
||||
}
|
||||
sz = tmp_sz;
|
||||
}
|
||||
|
||||
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
|
||||
if (!c) throw std::bad_alloc();
|
||||
|
||||
char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||
|
||||
c->m_next = cl->m_head;
|
||||
cl->m_head = c;
|
||||
cl->m_free = sz;
|
||||
cl->m_ptr = ptr;
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
inline void zone::push_finalizer(void (*func)(void*), void* data)
|
||||
{
|
||||
m_finalizer_array.push(func, data);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline void zone::push_finalizer(msgpack::unique_ptr<T> obj)
|
||||
{
|
||||
m_finalizer_array.push(&zone::object_delete<T>, obj.release());
|
||||
}
|
||||
|
||||
inline void zone::clear()
|
||||
{
|
||||
m_finalizer_array.clear();
|
||||
m_chunk_list.clear(m_chunk_size);
|
||||
}
|
||||
|
||||
inline void zone::swap(zone& o)
|
||||
{
|
||||
using std::swap;
|
||||
swap(m_chunk_size, o.m_chunk_size);
|
||||
swap(m_chunk_list, o.m_chunk_list);
|
||||
swap(m_finalizer_array, o.m_finalizer_array);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void zone::object_destruct(void* obj)
|
||||
{
|
||||
static_cast<T*>(obj)->~T();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void zone::object_delete(void* obj)
|
||||
{
|
||||
delete static_cast<T*>(obj);
|
||||
}
|
||||
|
||||
inline void zone::undo_allocate(size_t size)
|
||||
{
|
||||
m_chunk_list.m_ptr -= size;
|
||||
m_chunk_list.m_free += size;
|
||||
}
|
||||
|
||||
inline std::size_t aligned_size(
|
||||
std::size_t size,
|
||||
std::size_t align) {
|
||||
return (size + align - 1) / align * align;
|
||||
}
|
||||
|
||||
/// @cond
|
||||
<%0.upto(GENERATION_LIMIT) {|i|%>
|
||||
template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
|
||||
T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
|
||||
{
|
||||
void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
|
||||
try {
|
||||
m_finalizer_array.push(&zone::object_destruct<T>, x);
|
||||
} catch (...) {
|
||||
undo_allocate(sizeof(T));
|
||||
throw;
|
||||
}
|
||||
try {
|
||||
return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
|
||||
} catch (...) {
|
||||
--m_finalizer_array.m_tail;
|
||||
undo_allocate(sizeof(T));
|
||||
throw;
|
||||
}
|
||||
}
|
||||
<%}%>
|
||||
/// @endcond
|
||||
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_ZONE_HPP
|
||||
@ -1,54 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ memory pool
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_CPP03_ZONE_DECL_HPP
|
||||
#define MSGPACK_V1_CPP03_ZONE_DECL_HPP
|
||||
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "msgpack/versioning.hpp"
|
||||
|
||||
#ifndef MSGPACK_ZONE_CHUNK_SIZE
|
||||
#define MSGPACK_ZONE_CHUNK_SIZE 8192
|
||||
#endif
|
||||
|
||||
#ifndef MSGPACK_ZONE_ALIGN
|
||||
#define MSGPACK_ZONE_ALIGN sizeof(void*)
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
|
||||
#else
|
||||
#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
|
||||
#endif
|
||||
// For a compiler that doesn't support __alignof__:
|
||||
// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
|
||||
|
||||
<% GENERATION_LIMIT = 15 %>
|
||||
namespace msgpack {
|
||||
|
||||
/// @cond
|
||||
MSGPACK_API_VERSION_NAMESPACE(v1) {
|
||||
/// @endcond
|
||||
|
||||
class zone;
|
||||
|
||||
std::size_t aligned_size(
|
||||
std::size_t size,
|
||||
std::size_t align = MSGPACK_ZONE_ALIGN);
|
||||
|
||||
/// @cond
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(v1)
|
||||
/// @endcond
|
||||
|
||||
} // namespace msgpack
|
||||
|
||||
#endif // MSGPACK_V1_CPP03_ZONE_DECL_HPP
|
||||
@ -1,9 +0,0 @@
|
||||
IF (NOT MSGPACK_CXX_ONLY)
|
||||
ADD_SUBDIRECTORY (c)
|
||||
ENDIF ()
|
||||
IF (MSGPACK_ENABLE_CXX)
|
||||
ADD_SUBDIRECTORY (cpp03)
|
||||
ADD_SUBDIRECTORY (cpp11)
|
||||
ADD_SUBDIRECTORY (boost)
|
||||
ADD_SUBDIRECTORY (x3)
|
||||
ENDIF ()
|
||||
@ -1,56 +0,0 @@
|
||||
IF (MSGPACK_BOOST)
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
msgpack_variant_capitalize.cpp
|
||||
msgpack_variant_mapbased.cpp
|
||||
)
|
||||
IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
|
||||
FIND_PACKAGE (Threads REQUIRED)
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
asio_send_recv.cpp
|
||||
)
|
||||
IF (ZLIB_FOUND)
|
||||
INCLUDE_DIRECTORIES (
|
||||
${ZLIB_INCLUDE_DIRS}
|
||||
)
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
asio_send_recv_zlib.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
|
||||
FOREACH (source_file ${exec_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
${Boost_SYSTEM_LIBRARY}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
IF (ZLIB_FOUND)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
${ZLIB_LIBRARIES}
|
||||
)
|
||||
ENDIF()
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
@ -1,104 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2017 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
int main() {
|
||||
boost::asio::io_service ios;
|
||||
std::uint16_t const port = 12345;
|
||||
|
||||
// Server
|
||||
std::size_t const window_size = 10;
|
||||
boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
|
||||
boost::asio::ip::tcp::socket ss(ios);
|
||||
std::function<void()> do_accept;
|
||||
std::function<void()> do_async_read_some;
|
||||
|
||||
msgpack::unpacker unp;
|
||||
|
||||
do_accept = [&] {
|
||||
ac.async_accept(
|
||||
ss,
|
||||
[&]
|
||||
(boost::system::error_code const& e) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
do_async_read_some = [&] {
|
||||
unp.reserve_buffer(window_size);
|
||||
ss.async_read_some(
|
||||
boost::asio::buffer(unp.buffer(), window_size),
|
||||
[&](boost::system::error_code const& e, std::size_t bytes_transferred) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
std::cout << bytes_transferred << " bytes read." << std::endl;
|
||||
unp.buffer_consumed(bytes_transferred);
|
||||
msgpack::object_handle oh;
|
||||
while (unp.next(oh)) {
|
||||
std::cout << oh.get() << std::endl;
|
||||
// In order to finish the program,
|
||||
// return if one complete msgpack is processed.
|
||||
// In actual server, don't return here.
|
||||
return;
|
||||
}
|
||||
do_async_read_some();
|
||||
}
|
||||
);
|
||||
};
|
||||
do_async_read_some();
|
||||
}
|
||||
);
|
||||
};
|
||||
do_accept();
|
||||
|
||||
// Client
|
||||
auto host = "localhost";
|
||||
boost::asio::ip::tcp::resolver r(ios);
|
||||
|
||||
#if BOOST_VERSION < 106600
|
||||
boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
|
||||
auto it = r.resolve(q);
|
||||
boost::asio::ip::tcp::resolver::iterator end;
|
||||
#else // BOOST_VERSION < 106600
|
||||
auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
|
||||
auto it = eps.begin();
|
||||
auto end = eps.end();
|
||||
#endif // BOOST_VERSION < 106600
|
||||
|
||||
boost::asio::ip::tcp::socket cs(ios);
|
||||
boost::asio::async_connect(
|
||||
cs,
|
||||
it,
|
||||
end,
|
||||
[&]
|
||||
(boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
std::cout << __LINE__ << ":client connected" << std::endl;
|
||||
msgpack::sbuffer sb;
|
||||
msgpack::pack(sb, std::make_tuple(42, false, "hello world", 12.3456));
|
||||
write(cs, boost::asio::buffer(sb.data(), sb.size()));
|
||||
}
|
||||
);
|
||||
|
||||
// Start
|
||||
ios.run();
|
||||
}
|
||||
@ -1,176 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2017 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <msgpack/zbuffer.hpp>
|
||||
|
||||
#include <zlib.h>
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
boost::asio::io_service ios;
|
||||
std::uint16_t const port = 12345;
|
||||
|
||||
int num_of_zlib_data = 2;
|
||||
int idx_zlib_data = 0;
|
||||
|
||||
// Server
|
||||
std::size_t const window_size = 11;
|
||||
boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
|
||||
boost::asio::ip::tcp::socket ss(ios);
|
||||
std::function<void()> do_accept;
|
||||
std::function<void()> do_async_read_some;
|
||||
|
||||
// zlib for decompress
|
||||
z_stream strm;
|
||||
auto zlib_init = [&] {
|
||||
strm.zalloc = Z_NULL;
|
||||
strm.zfree = Z_NULL;
|
||||
strm.opaque = Z_NULL;
|
||||
strm.next_in = Z_NULL;
|
||||
{
|
||||
int zret = inflateInit(&strm);
|
||||
if (zret != Z_OK) {
|
||||
std::cout << "Zlib inflateInit() error = " << zret << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
zlib_init();
|
||||
std::vector<char> buf(4); // buf size
|
||||
|
||||
msgpack::unpacker unp;
|
||||
|
||||
do_accept = [&] {
|
||||
ac.async_accept(
|
||||
ss,
|
||||
[&]
|
||||
(boost::system::error_code const& e) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
do_async_read_some = [&] {
|
||||
ss.async_read_some(
|
||||
boost::asio::buffer(buf),
|
||||
[&](boost::system::error_code const& e, std::size_t bytes_transferred) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
std::cout << bytes_transferred << " bytes read." << std::endl;
|
||||
print(std::string(std::string(&buf[0], buf.size())));
|
||||
strm.avail_in = bytes_transferred;
|
||||
do {
|
||||
strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in);
|
||||
int zret;
|
||||
unp.reserve_buffer(window_size);
|
||||
strm.avail_out = window_size;
|
||||
strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer());
|
||||
do {
|
||||
zret = inflate(&strm, Z_NO_FLUSH);
|
||||
assert(zret != Z_STREAM_ERROR);
|
||||
switch (zret) {
|
||||
case Z_NEED_DICT:
|
||||
zret = Z_DATA_ERROR;
|
||||
// fall through
|
||||
case Z_DATA_ERROR:
|
||||
case Z_MEM_ERROR:
|
||||
inflateEnd(&strm);
|
||||
std::cout << "Zlib inflate() error = " << zret << std::endl;
|
||||
std::exit(-1);
|
||||
}
|
||||
std::size_t decompressed_size = window_size - strm.avail_out;
|
||||
std::cout << decompressed_size << " bytes decompressed." << std::endl;
|
||||
unp.buffer_consumed(decompressed_size);
|
||||
msgpack::object_handle oh;
|
||||
while (unp.next(oh)) {
|
||||
std::cout << oh.get() << std::endl;
|
||||
}
|
||||
} while (strm.avail_out == 0);
|
||||
if (zret == Z_STREAM_END) {
|
||||
inflateEnd(&strm);
|
||||
std::cout << "Zlib decompress finished." << std::endl;
|
||||
++idx_zlib_data;
|
||||
if (idx_zlib_data == num_of_zlib_data) {
|
||||
std::cout << "All zlib decompress finished." << std::endl;
|
||||
return;
|
||||
}
|
||||
zlib_init();
|
||||
}
|
||||
} while (strm.avail_in != 0);
|
||||
do_async_read_some();
|
||||
}
|
||||
);
|
||||
};
|
||||
do_async_read_some();
|
||||
}
|
||||
);
|
||||
};
|
||||
do_accept();
|
||||
|
||||
// Client
|
||||
auto host = "localhost";
|
||||
|
||||
boost::asio::ip::tcp::resolver r(ios);
|
||||
|
||||
#if BOOST_VERSION < 106600
|
||||
boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
|
||||
auto it = r.resolve(q);
|
||||
boost::asio::ip::tcp::resolver::iterator end;
|
||||
#else // BOOST_VERSION < 106600
|
||||
auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
|
||||
auto it = eps.begin();
|
||||
auto end = eps.end();
|
||||
#endif // BOOST_VERSION < 106600
|
||||
|
||||
boost::asio::ip::tcp::socket cs(ios);
|
||||
boost::asio::async_connect(
|
||||
cs,
|
||||
it,
|
||||
end,
|
||||
[&]
|
||||
(boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
|
||||
if (e) {
|
||||
std::cout << __LINE__ << ":" << e.message() << std::endl;
|
||||
return;
|
||||
}
|
||||
std::cout << __LINE__ << ":client connected" << std::endl;
|
||||
for (int i = 0; i != num_of_zlib_data; ++i) {
|
||||
msgpack::zbuffer zb;
|
||||
msgpack::pack(zb, std::make_tuple(i, false, "hello world", 12.3456));
|
||||
zb.flush(); // finalize zbuffer (don't forget it)
|
||||
print(std::string(zb.data(), zb.size()));
|
||||
write(cs, boost::asio::buffer(zb.data(), zb.size()));
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Start
|
||||
ios.run();
|
||||
}
|
||||
@ -1,94 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct user {
|
||||
std::string name;
|
||||
int age;
|
||||
std::string address;
|
||||
MSGPACK_DEFINE(name, age, address);
|
||||
};
|
||||
|
||||
struct proc:boost::static_visitor<void> {
|
||||
void operator()(std::string& v) const {
|
||||
std::cout << " match std::string& v" << std::endl;
|
||||
std::cout << " v: " << v << std::endl;
|
||||
std::cout << " capitalize" << std::endl;
|
||||
for (std::string::iterator it = v.begin(), end = v.end();
|
||||
it != end;
|
||||
++it) {
|
||||
*it = std::toupper(*it);
|
||||
}
|
||||
}
|
||||
void operator()(std::vector<msgpack::type::variant>& v) const {
|
||||
std::cout << "match vector (msgpack::type::ARRAY)" << std::endl;
|
||||
std::vector<msgpack::type::variant>::iterator it = v.begin();
|
||||
std::vector<msgpack::type::variant>::const_iterator end = v.end();
|
||||
for (; it != end; ++it) {
|
||||
boost::apply_visitor(*this, *it);
|
||||
}
|
||||
}
|
||||
template <typename T>
|
||||
void operator()(T const&) const {
|
||||
std::cout << " match others" << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
std::stringstream ss1;
|
||||
user u;
|
||||
u.name = "Takatoshi Kondo";
|
||||
u.age = 42;
|
||||
u.address = "Tokyo, JAPAN";
|
||||
|
||||
std::cout << "Packing object." << std::endl;
|
||||
msgpack::pack(ss1, u);
|
||||
print(ss1.str());
|
||||
|
||||
msgpack::object_handle oh1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
|
||||
msgpack::object const& obj1 = oh1.get();
|
||||
std::cout << "Unpacked msgpack object." << std::endl;
|
||||
std::cout << obj1 << std::endl;
|
||||
|
||||
msgpack::type::variant v = obj1.as<msgpack::type::variant>();
|
||||
std::cout << "Applying proc..." << std::endl;
|
||||
boost::apply_visitor(proc(), v);
|
||||
|
||||
std::stringstream ss2;
|
||||
std::cout << "Packing modified object." << std::endl;
|
||||
msgpack::pack(ss2, v);
|
||||
print(ss2.str());
|
||||
|
||||
msgpack::object_handle oh2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
|
||||
msgpack::object const& obj2 = oh2.get();
|
||||
std::cout << "Modified msgpack object." << std::endl;
|
||||
std::cout << obj2 << std::endl;
|
||||
}
|
||||
@ -1,97 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct user {
|
||||
std::string name;
|
||||
int age;
|
||||
std::string address;
|
||||
MSGPACK_DEFINE_MAP(name, age, address);
|
||||
};
|
||||
|
||||
struct proc:boost::static_visitor<void> {
|
||||
// msgpack::type::MAP is converted to std::multimap, not std::map.
|
||||
void operator()(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>& v) const {
|
||||
std::cout << "match map" << std::endl;
|
||||
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator it = v.begin();
|
||||
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator end = v.end();
|
||||
while(it != end) {
|
||||
boost::string_ref const& key = it->first.as_boost_string_ref();
|
||||
if (key == "name") {
|
||||
boost::string_ref const& value = it->second.as_boost_string_ref();
|
||||
if (value == "Takatoshi Kondo") {
|
||||
// You can add values to msgpack::type::variant_ref.
|
||||
v.insert(
|
||||
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::value_type(
|
||||
"role",
|
||||
"msgpack-c committer"
|
||||
)
|
||||
);
|
||||
}
|
||||
++it;
|
||||
}
|
||||
else if (key == "age") {
|
||||
// You can remove key-value pair from msgpack::type::variant_ref
|
||||
|
||||
#if defined(MSGPACK_USE_CPP03)
|
||||
# if MSGPACK_LIB_STD_CXX
|
||||
v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it++));
|
||||
# else // MSGPACK_LIB_STD_CXX
|
||||
v.erase(it++);
|
||||
# endif // MSGPACK_LIB_STD_CXX
|
||||
#else // defined(MSGPACK_USE_CPP03)
|
||||
# if MSGPACK_LIB_STD_CXX
|
||||
it = v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it));
|
||||
# else // MSGPACK_LIB_STD_CXX
|
||||
it = v.erase(it);
|
||||
# endif // MSGPACK_LIB_STD_CXX
|
||||
#endif // defined(MSGPACK_USE_CPP03)
|
||||
}
|
||||
else if (key == "address") {
|
||||
// When you want to append string
|
||||
// "Tokyo" -> "Tokyo, JAPAN"
|
||||
// Use msgpack::type::variant instead of msgpack::type::variant_ref
|
||||
// or do as follows:
|
||||
boost::string_ref const& value = it->second.as_boost_string_ref();
|
||||
it->second = std::string(&value.front(), value.size()) + ", JAPAN";
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
template <typename T>
|
||||
void operator()(T const&) const {
|
||||
std::cout << " match others" << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
int main() {
|
||||
std::stringstream ss;
|
||||
user u;
|
||||
u.name = "Takatoshi Kondo";
|
||||
u.age = 42;
|
||||
u.address = "Tokyo";
|
||||
msgpack::pack(ss, u);
|
||||
|
||||
std::string const& str = ss.str();
|
||||
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
|
||||
msgpack::object const& obj = oh.get();
|
||||
std::cout << "Unpacked msgpack object." << std::endl;
|
||||
std::cout << obj << std::endl;
|
||||
msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();
|
||||
std::cout << "Applying proc..." << std::endl;
|
||||
boost::apply_visitor(proc(), v);
|
||||
msgpack::zone z;
|
||||
std::cout << "Applied msgpack object." << std::endl;
|
||||
std::cout << msgpack::object(v, z) << std::endl;
|
||||
}
|
||||
@ -1,120 +0,0 @@
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
class_intrusive.cpp
|
||||
class_intrusive_map.cpp
|
||||
class_non_intrusive.cpp
|
||||
custom.cpp
|
||||
enum.cpp
|
||||
map_based_versionup.cpp
|
||||
protocol_new.cpp
|
||||
reuse_zone.cpp
|
||||
simple.cpp
|
||||
)
|
||||
|
||||
IF (MSGPACK_DEFAULT_API_VERSION EQUAL 1)
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
protocol.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
|
||||
IF (NOT MSVC)
|
||||
LIST (APPEND with_pthread_PROGRAMS
|
||||
stream.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
|
||||
IF (MSGPACK_BOOST)
|
||||
LIST (APPEND with_boost_lib_PROGRAMS
|
||||
speed_test.cpp
|
||||
speed_test_nested_array.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
|
||||
FOREACH (source_file ${exec_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
|
||||
FOREACH (source_file ${with_pthread_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
|
||||
FOREACH (source_file ${with_boost_lib_PROGRAMS})
|
||||
INCLUDE_DIRECTORIES (
|
||||
../include
|
||||
${Boost_INCLUDE_DIRS}
|
||||
)
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
${Boost_TIMER_LIBRARY}
|
||||
${Boost_CHRONO_LIBRARY}
|
||||
${Boost_SYSTEM_LIBRARY}
|
||||
)
|
||||
IF (NOT MSVC AND NOT APPLE)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
rt
|
||||
)
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -O3")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
@ -1,104 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
// When you want to adapt map instead of array, you can enable these macro definition.
|
||||
//
|
||||
// #define MSGPACK_USE_DEFINE_MAP
|
||||
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct my_base1 {
|
||||
int a;
|
||||
MSGPACK_DEFINE(a);
|
||||
};
|
||||
inline bool operator==(my_base1 const& lhs, my_base1 const& rhs) {
|
||||
return lhs.a == rhs.a;
|
||||
}
|
||||
|
||||
struct my_base2 {
|
||||
std::string b;
|
||||
std::string c;
|
||||
MSGPACK_DEFINE(b, c);
|
||||
};
|
||||
inline bool operator==(my_base2 const& lhs, my_base2 const& rhs) {
|
||||
return lhs.b == rhs.b && lhs.c == rhs.c;
|
||||
}
|
||||
|
||||
class my_class : public my_base1, private my_base2 {
|
||||
public:
|
||||
my_class() {} // When you want to convert from msgpack::object to my_class,
|
||||
// my_class should be default constractible.
|
||||
my_class(std::string const& name, int age):name_(name), age_(age) {}
|
||||
void set_b(std::string const& str) { b = str; }
|
||||
void set_c(std::string const& str) { c = str; }
|
||||
friend bool operator==(my_class const& lhs, my_class const& rhs) {
|
||||
return
|
||||
static_cast<my_base1 const&>(lhs) == static_cast<my_base1 const&>(rhs) &&
|
||||
static_cast<my_base2 const&>(lhs) == static_cast<my_base2 const&>(rhs) &&
|
||||
lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string name_;
|
||||
int age_;
|
||||
|
||||
public:
|
||||
MSGPACK_DEFINE(name_, age_, MSGPACK_BASE(my_base1), MSGPACK_BASE(my_base2));
|
||||
};
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ // pack, unpack
|
||||
my_class my("John Smith", 42);
|
||||
my.a = 123;
|
||||
my.set_b("ABC");
|
||||
my.set_c("DEF");
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, my);
|
||||
|
||||
std::string const& str = ss.str();
|
||||
print(str);
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(str.data(), str.size());
|
||||
msgpack::object obj = oh.get();
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
{ // create object with zone
|
||||
my_class my("John Smith", 42);
|
||||
my.a = 123;
|
||||
my.set_b("ABC");
|
||||
my.set_c("DEF");
|
||||
msgpack::zone z;
|
||||
msgpack::object obj(my, z);
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
}
|
||||
@ -1,76 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
|
||||
class my_class {
|
||||
public:
|
||||
my_class() {} // When you want to convert from msgpack::object to my_class,
|
||||
// my_class should be default constractible.
|
||||
// If you use C++11, you can adapt non-default constructible
|
||||
// classes to msgpack::object.
|
||||
// See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_adaptor#non-default-constructible-class-support-c11-only
|
||||
my_class(std::string const& name, int age):name_(name), age_(age) {}
|
||||
|
||||
friend bool operator==(my_class const& lhs, my_class const& rhs) {
|
||||
return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string name_;
|
||||
int age_;
|
||||
|
||||
public:
|
||||
MSGPACK_DEFINE_MAP(name_, age_);
|
||||
};
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ // pack, unpack
|
||||
my_class my("John Smith", 42);
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, my);
|
||||
|
||||
print(ss.str());
|
||||
|
||||
std::string const& str = ss.str();
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(str.data(), str.size());
|
||||
msgpack::object obj = oh.get();
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
{ // create object with zone
|
||||
my_class my("John Smith", 42);
|
||||
msgpack::zone z;
|
||||
msgpack::object obj(my, z);
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
class my_class {
|
||||
public:
|
||||
my_class() {} // When you want to convert from msgpack::object to my_class,
|
||||
// my_class should be default constractible.
|
||||
my_class(std::string const& name, int age):name_(name), age_(age) {}
|
||||
|
||||
// my_class should provide getters for the data members you want to pack.
|
||||
std::string const& get_name() const { return name_; }
|
||||
int get_age() const { return age_; }
|
||||
|
||||
friend bool operator==(my_class const& lhs, my_class const& rhs) {
|
||||
return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string name_;
|
||||
int age_;
|
||||
};
|
||||
|
||||
// User defined class template specialization
|
||||
namespace msgpack {
|
||||
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
|
||||
namespace adaptor {
|
||||
|
||||
template<>
|
||||
struct convert<my_class> {
|
||||
msgpack::object const& operator()(msgpack::object const& o, my_class& v) const {
|
||||
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
|
||||
if (o.via.array.size != 2) throw msgpack::type_error();
|
||||
v = my_class(
|
||||
o.via.array.ptr[0].as<std::string>(),
|
||||
o.via.array.ptr[1].as<int>());
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct pack<my_class> {
|
||||
template <typename Stream>
|
||||
packer<Stream>& operator()(msgpack::packer<Stream>& o, my_class const& v) const {
|
||||
// packing member variables as an array.
|
||||
o.pack_array(2);
|
||||
o.pack(v.get_name());
|
||||
o.pack(v.get_age());
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct object_with_zone<my_class> {
|
||||
void operator()(msgpack::object::with_zone& o, my_class const& v) const {
|
||||
o.type = type::ARRAY;
|
||||
o.via.array.size = 2;
|
||||
o.via.array.ptr = static_cast<msgpack::object*>(
|
||||
o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
|
||||
o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
|
||||
o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace adaptor
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
|
||||
} // namespace msgpack
|
||||
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ // pack, unpack
|
||||
my_class my("John Smith", 42);
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, my);
|
||||
|
||||
std::string const& str = ss.str();
|
||||
print(str);
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(str.data(), str.size());
|
||||
msgpack::object obj = oh.get();
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
{ // create object with zone
|
||||
my_class my("John Smith", 42);
|
||||
msgpack::zone z;
|
||||
msgpack::object obj(my, z);
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<my_class>() == my);
|
||||
}
|
||||
}
|
||||
@ -1,67 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
class old_class {
|
||||
public:
|
||||
old_class() : value("default") { }
|
||||
|
||||
std::string value;
|
||||
|
||||
MSGPACK_DEFINE(value);
|
||||
};
|
||||
|
||||
class new_class {
|
||||
public:
|
||||
new_class() : value("default"), flag(-1) { }
|
||||
|
||||
std::string value;
|
||||
int flag;
|
||||
|
||||
MSGPACK_DEFINE(value, flag);
|
||||
};
|
||||
|
||||
int main(void)
|
||||
{
|
||||
{
|
||||
old_class oc;
|
||||
new_class nc;
|
||||
|
||||
std::stringstream sbuf;
|
||||
msgpack::pack(sbuf, oc);
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(sbuf.str().data(), sbuf.str().size());
|
||||
msgpack::object obj = oh.get();
|
||||
|
||||
obj.convert(nc);
|
||||
|
||||
std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
|
||||
}
|
||||
|
||||
{
|
||||
new_class nc;
|
||||
old_class oc;
|
||||
|
||||
std::stringstream sbuf;
|
||||
msgpack::pack(sbuf, nc);
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(sbuf.str().data(), sbuf.str().size());
|
||||
msgpack::object obj = oh.get();
|
||||
|
||||
obj.convert(oc);
|
||||
|
||||
std::cout << obj << " value=" << oc.value << std::endl;
|
||||
}
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <cassert>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
enum my_enum {
|
||||
elem1,
|
||||
elem2,
|
||||
elem3
|
||||
};
|
||||
|
||||
MSGPACK_ADD_ENUM(my_enum);
|
||||
|
||||
int main(void)
|
||||
{
|
||||
{ // pack, unpack
|
||||
std::stringstream sbuf;
|
||||
msgpack::pack(sbuf, elem1);
|
||||
msgpack::pack(sbuf, elem2);
|
||||
my_enum e3 = elem3;
|
||||
msgpack::pack(sbuf, e3);
|
||||
|
||||
msgpack::object_handle oh;
|
||||
std::size_t off = 0;
|
||||
|
||||
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
|
||||
std::cout << oh.get().as<my_enum>() << std::endl;
|
||||
assert(oh.get().as<my_enum>() == elem1);
|
||||
|
||||
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
|
||||
std::cout << oh.get().as<my_enum>() << std::endl;
|
||||
assert(oh.get().as<my_enum>() == elem2);
|
||||
|
||||
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
|
||||
std::cout << oh.get().as<my_enum>() << std::endl;
|
||||
assert(oh.get().as<my_enum>() == elem3);
|
||||
}
|
||||
{ // create object without zone
|
||||
msgpack::object obj(elem2);
|
||||
std::cout << obj.as<my_enum>() << std::endl;
|
||||
assert(obj.as<my_enum>() == elem2);
|
||||
}
|
||||
{ // create object with zone
|
||||
msgpack::zone z;
|
||||
msgpack::object objz(elem3, z);
|
||||
std::cout << objz.as<my_enum>() << std::endl;
|
||||
assert(objz.as<my_enum>() == elem3);
|
||||
}
|
||||
}
|
||||
@ -1,112 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct base1 {
|
||||
base1():a("default") {}
|
||||
std::string a;
|
||||
MSGPACK_DEFINE_MAP(a);
|
||||
};
|
||||
|
||||
struct v1 : base1 {
|
||||
v1():name("default"), age(0) {}
|
||||
std::string name;
|
||||
int age;
|
||||
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base1), name, age);
|
||||
};
|
||||
|
||||
struct base2 {
|
||||
base2():a("default") {}
|
||||
std::string a;
|
||||
MSGPACK_DEFINE_MAP(a);
|
||||
};
|
||||
|
||||
// Removed: base1, name
|
||||
// Added : base2, address
|
||||
struct v2 : base2 {
|
||||
v2(): age(0), address("default") {}
|
||||
int age;
|
||||
std::string address;
|
||||
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base2), age, address);
|
||||
};
|
||||
|
||||
// The member variable "age" is in common between v1 and v2.
|
||||
|
||||
void print(std::string const& buf) {
|
||||
for (std::string::const_iterator it = buf.begin(), end = buf.end();
|
||||
it != end;
|
||||
++it) {
|
||||
std::cout
|
||||
<< std::setw(2)
|
||||
<< std::hex
|
||||
<< std::setfill('0')
|
||||
<< (static_cast<int>(*it) & 0xff)
|
||||
<< ' ';
|
||||
}
|
||||
std::cout << std::dec << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ // pack v1, unpack, convert to v2
|
||||
v1 v;
|
||||
v.a = "ABC";
|
||||
v.name = "John Smith";
|
||||
v.age = 35;
|
||||
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, v);
|
||||
|
||||
print(ss.str());
|
||||
|
||||
std::string const& str = ss.str();
|
||||
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
|
||||
|
||||
msgpack::object obj = oh.get();
|
||||
std::cout << obj << std::endl;
|
||||
|
||||
v2 newv = obj.as<v2>();
|
||||
|
||||
std::cout << "v2::a " << newv.a << std::endl;
|
||||
std::cout << "v2::age " << newv.age << std::endl;
|
||||
std::cout << "v2::address " << newv.address << std::endl;
|
||||
|
||||
// "age" is set from v1
|
||||
assert(newv.a == "default");
|
||||
assert(newv.age == 35);
|
||||
assert(newv.address == "default");
|
||||
}
|
||||
{ // create v2 object with zone, convert to v1
|
||||
v2 v;
|
||||
v.a = "DEF";
|
||||
v.age = 42;
|
||||
v.address = "Tokyo";
|
||||
|
||||
msgpack::zone z;
|
||||
msgpack::object obj(v, z);
|
||||
std::cout << obj << std::endl;
|
||||
|
||||
v1 newv = obj.as<v1>();
|
||||
|
||||
std::cout << "v1::a " << newv.a << std::endl;
|
||||
std::cout << "v1::name " << newv.name << std::endl;
|
||||
std::cout << "v1::age " << newv.age << std::endl;
|
||||
|
||||
// "age" is set from v2
|
||||
assert(newv.a == "default");
|
||||
assert(newv.name == "default");
|
||||
assert(newv.age == 42);
|
||||
}
|
||||
}
|
||||
@ -1,97 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
// This example uses obsolete APIs
|
||||
// See protocol_new.cpp
|
||||
namespace myprotocol {
|
||||
using namespace msgpack::type;
|
||||
using msgpack::define;
|
||||
|
||||
struct Get : define< tuple<uint32_t, std::string> > {
|
||||
Get() { }
|
||||
Get(uint32_t f, const std::string& k) :
|
||||
define_type(msgpack_type(f, k)) { }
|
||||
uint32_t& flags() { return msgpack::type::get<0>(*this); }
|
||||
std::string& key() { return msgpack::type::get<1>(*this); }
|
||||
};
|
||||
|
||||
struct Put : define< tuple<uint32_t, std::string, raw_ref> > {
|
||||
Put() { }
|
||||
Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) :
|
||||
define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { }
|
||||
uint32_t& flags() { return msgpack::type::get<0>(*this); }
|
||||
std::string& key() { return msgpack::type::get<1>(*this); }
|
||||
raw_ref& value() { return msgpack::type::get<2>(*this); }
|
||||
};
|
||||
|
||||
struct MultiGet : define< std::vector<Get> > {
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
// send Get request
|
||||
std::stringstream stream;
|
||||
{
|
||||
myprotocol::Get req;
|
||||
req.flags() = 0;
|
||||
req.key() = "key0";
|
||||
msgpack::pack(stream, req);
|
||||
}
|
||||
|
||||
stream.seekg(0);
|
||||
|
||||
// receive Get request
|
||||
{
|
||||
std::string buffer(stream.str());
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(buffer.data(), buffer.size());
|
||||
msgpack::object o = oh.get();
|
||||
|
||||
myprotocol::Get req;
|
||||
o.convert(req);
|
||||
std::cout << "received: " << o << std::endl;
|
||||
}
|
||||
|
||||
|
||||
stream.str("");
|
||||
|
||||
|
||||
// send MultiGet request
|
||||
{
|
||||
myprotocol::MultiGet req;
|
||||
req.push_back( myprotocol::Get(1, "key1") );
|
||||
req.push_back( myprotocol::Get(2, "key2") );
|
||||
req.push_back( myprotocol::Get(3, "key3") );
|
||||
msgpack::pack(stream, req);
|
||||
}
|
||||
|
||||
stream.seekg(0);
|
||||
|
||||
// receive MultiGet request
|
||||
{
|
||||
std::string buffer(stream.str());
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(buffer.data(), buffer.size());
|
||||
msgpack::object o = oh.get();
|
||||
|
||||
|
||||
myprotocol::MultiGet req;
|
||||
o.convert(req);
|
||||
std::cout << "received: " << o << std::endl;
|
||||
}
|
||||
}
|
||||
@ -1,84 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
// This example uses obsolete APIs
|
||||
// See protocol_new.cpp
|
||||
namespace myprotocol {
|
||||
struct Get {
|
||||
Get() {}
|
||||
Get(uint32_t f, const std::string& k) : flags(f), key(k) {}
|
||||
uint32_t flags;
|
||||
std::string key;
|
||||
MSGPACK_DEFINE(flags, key);
|
||||
};
|
||||
|
||||
typedef std::vector<Get> MultiGet;
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
// send Get request
|
||||
std::stringstream stream;
|
||||
{
|
||||
myprotocol::Get req;
|
||||
req.flags = 0;
|
||||
req.key = "key0";
|
||||
msgpack::pack(stream, req);
|
||||
}
|
||||
|
||||
stream.seekg(0);
|
||||
|
||||
// receive Get request
|
||||
{
|
||||
std::string buffer(stream.str());
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(buffer.data(), buffer.size());
|
||||
msgpack::object o = oh.get();
|
||||
|
||||
myprotocol::Get req;
|
||||
o.convert(req);
|
||||
std::cout << "received: " << o << std::endl;
|
||||
}
|
||||
|
||||
|
||||
stream.str("");
|
||||
|
||||
|
||||
// send MultiGet request
|
||||
{
|
||||
myprotocol::MultiGet req;
|
||||
req.push_back( myprotocol::Get(1, "key1") );
|
||||
req.push_back( myprotocol::Get(2, "key2") );
|
||||
req.push_back( myprotocol::Get(3, "key3") );
|
||||
msgpack::pack(stream, req);
|
||||
}
|
||||
|
||||
stream.seekg(0);
|
||||
|
||||
// receive MultiGet request
|
||||
{
|
||||
std::string buffer(stream.str());
|
||||
|
||||
msgpack::object_handle oh =
|
||||
msgpack::unpack(buffer.data(), buffer.size());
|
||||
msgpack::object o = oh.get();
|
||||
|
||||
|
||||
myprotocol::MultiGet req;
|
||||
o.convert(req);
|
||||
std::cout << "received: " << o << std::endl;
|
||||
}
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
|
||||
int main() {
|
||||
std::vector<int> v;
|
||||
v.push_back(1);
|
||||
v.push_back(42);
|
||||
std::string s("ABC");
|
||||
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, v);
|
||||
msgpack::pack(ss, s);
|
||||
|
||||
msgpack::zone z;
|
||||
std::size_t offset = 0;
|
||||
|
||||
// msgpack array is constructed on z.
|
||||
std::string const& ps = ss.str();
|
||||
msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset);
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<std::vector<int> >() == v);
|
||||
|
||||
// msgpack str is constructed on z.
|
||||
std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as<std::string>();
|
||||
std::cout << str << std::endl;
|
||||
assert(str == s);
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
|
||||
|
||||
// serialize the object into the buffer.
|
||||
// any classes that implements write(const char*,size_t) can be a buffer.
|
||||
std::stringstream buffer;
|
||||
msgpack::pack(buffer, src);
|
||||
|
||||
// send the buffer ...
|
||||
buffer.seekg(0);
|
||||
|
||||
// deserialize the buffer into msgpack::object instance.
|
||||
std::string str(buffer.str());
|
||||
|
||||
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
|
||||
|
||||
// deserialized object is valid during the msgpack::object_handle instance alive.
|
||||
msgpack::object deserialized = oh.get();
|
||||
|
||||
// msgpack::object supports ostream.
|
||||
std::cout << deserialized << std::endl;
|
||||
|
||||
// convert msgpack::object instance into the original type.
|
||||
// if the type is mismatched, it throws msgpack::type_error exception.
|
||||
msgpack::type::tuple<int, bool, std::string> dst;
|
||||
deserialized.convert(dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,63 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2013-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)
|
||||
//
|
||||
|
||||
// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
|
||||
// export LD_LIBRARY_PATH=path_to_boost_lib
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <map>
|
||||
#include <boost/timer/timer.hpp>
|
||||
|
||||
void test_map_pack_unpack() {
|
||||
std::cout << "[TEST][map_pack_unpack]" << std::endl;
|
||||
// setup
|
||||
std::cout << "Setting up map data..." << std::endl;
|
||||
std::map<int, int> m1;
|
||||
int const num = 30000000L;
|
||||
for (int i = 0; i < num; ++i) m1[i] = i;
|
||||
std::cout << "Start packing..." << std::endl;
|
||||
std::stringstream buffer;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
msgpack::pack(buffer, m1);
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Pack finished..." << std::endl;
|
||||
|
||||
buffer.seekg(0);
|
||||
std::string str(buffer.str());
|
||||
|
||||
msgpack::object_handle oh;
|
||||
std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
msgpack::unpack(oh, str.data(), str.size());
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Unpack finished..." << std::endl;
|
||||
std::map<int, int> m2;
|
||||
std::cout << "Start converting..." << std::endl;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
oh.get().convert(m2);
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Convert finished..." << std::endl;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_map_pack_unpack();
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2013-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)
|
||||
//
|
||||
|
||||
// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
|
||||
// export LD_LIBRARY_PATH=path_to_boost_lib
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
#include <boost/timer/timer.hpp>
|
||||
|
||||
template <typename T, std::size_t level>
|
||||
struct vecvec {
|
||||
typedef std::vector<typename vecvec<T, level - 1>::type> type;
|
||||
static void fill(type& v, std::size_t num_of_elems, T const& val) {
|
||||
for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
|
||||
typename vecvec<T, level - 1>::type child;
|
||||
vecvec<T, level - 1>::fill(child, num_of_elems, val);
|
||||
v.push_back(child);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct vecvec<T, 0> {
|
||||
typedef std::vector<T> type;
|
||||
static void fill(type& v, std::size_t num_of_elems, T const& val) {
|
||||
for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
|
||||
v.push_back(val);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
void test_array_of_array() {
|
||||
std::cout << "[TEST][array_of_array]" << std::endl;
|
||||
// setup
|
||||
int const depth = 4;
|
||||
std::cout << "Setting up array data..." << std::endl;
|
||||
vecvec<int, depth>::type v1;
|
||||
vecvec<int, depth>::fill(v1, 3, 42);
|
||||
|
||||
std::cout << "Start packing..." << std::endl;
|
||||
std::stringstream buffer;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
msgpack::pack(buffer, v1);
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Pack finished..." << std::endl;
|
||||
|
||||
buffer.seekg(0);
|
||||
std::string str(buffer.str());
|
||||
|
||||
msgpack::object_handle oh;
|
||||
std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
msgpack::unpack(oh, str.data(), str.size());
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Unpack finished..." << std::endl;
|
||||
vecvec<int, depth>::type v2;
|
||||
std::cout << "Start converting..." << std::endl;
|
||||
{
|
||||
boost::timer::cpu_timer timer;
|
||||
oh.get().convert(v2);
|
||||
std::string result = timer.format();
|
||||
std::cout << result << std::endl;
|
||||
}
|
||||
std::cout << "Convert finished..." << std::endl;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_array_of_array();
|
||||
}
|
||||
@ -1,148 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <msgpack.hpp>
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
#include <io.h>
|
||||
#include <fcntl.h>
|
||||
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
|
||||
#endif // _MSC_VER || __MINGW32__
|
||||
|
||||
class Server {
|
||||
public:
|
||||
Server(int sock) : m_sock(sock) { }
|
||||
|
||||
~Server() { }
|
||||
|
||||
typedef msgpack::unique_ptr<msgpack::zone> unique_zone;
|
||||
|
||||
void socket_readable()
|
||||
{
|
||||
m_pac.reserve_buffer(1024);
|
||||
|
||||
ssize_t count =
|
||||
read(m_sock, m_pac.buffer(), m_pac.buffer_capacity());
|
||||
|
||||
if(count <= 0) {
|
||||
if(count == 0) {
|
||||
throw std::runtime_error("connection closed");
|
||||
}
|
||||
if(errno == EAGAIN || errno == EINTR) {
|
||||
return;
|
||||
}
|
||||
throw std::runtime_error(strerror(errno));
|
||||
}
|
||||
|
||||
m_pac.buffer_consumed(count);
|
||||
|
||||
msgpack::object_handle oh;
|
||||
while (m_pac.next(oh)) {
|
||||
msgpack::object msg = oh.get();
|
||||
unique_zone& life = oh.zone();
|
||||
process_message(msg, life);
|
||||
}
|
||||
|
||||
if(m_pac.message_size() > 10*1024*1024) {
|
||||
throw std::runtime_error("message is too large");
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void process_message(msgpack::object msg, unique_zone&)
|
||||
{
|
||||
std::cout << "message reached: " << msg << std::endl;
|
||||
}
|
||||
|
||||
private:
|
||||
int m_sock;
|
||||
msgpack::unpacker m_pac;
|
||||
};
|
||||
|
||||
|
||||
static void* run_server(void* arg)
|
||||
{
|
||||
try {
|
||||
Server* srv = reinterpret_cast<Server*>(arg);
|
||||
|
||||
while(true) {
|
||||
srv->socket_readable();
|
||||
}
|
||||
return NULL;
|
||||
|
||||
} catch (std::exception& e) {
|
||||
std::cerr << "error while processing client packet: "
|
||||
<< e.what() << std::endl;
|
||||
return NULL;
|
||||
|
||||
} catch (...) {
|
||||
std::cerr << "error while processing client packet: "
|
||||
<< "unknown error" << std::endl;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
struct fwriter {
|
||||
fwriter(int fd) : m_fp( fdopen(fd, "w") ) { }
|
||||
|
||||
void write(const char* buf, size_t buflen)
|
||||
{
|
||||
size_t count = fwrite(buf, buflen, 1, m_fp);
|
||||
if(count < 1) {
|
||||
std::cout << buflen << std::endl;
|
||||
std::cout << count << std::endl;
|
||||
throw std::runtime_error(strerror(errno));
|
||||
}
|
||||
}
|
||||
|
||||
void flush() { fflush(m_fp); }
|
||||
|
||||
void close() { fclose(m_fp); }
|
||||
|
||||
private:
|
||||
FILE* m_fp;
|
||||
};
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int pair[2];
|
||||
if (pipe(pair) != 0) return -1;
|
||||
|
||||
// run server thread
|
||||
Server srv(pair[0]);
|
||||
pthread_t thread;
|
||||
pthread_create(&thread, NULL,
|
||||
run_server, reinterpret_cast<void*>(&srv));
|
||||
|
||||
// client thread:
|
||||
fwriter writer(pair[1]);
|
||||
msgpack::packer<fwriter> pk(writer);
|
||||
|
||||
typedef msgpack::type::tuple<std::string, std::string, std::string> put_t;
|
||||
typedef msgpack::type::tuple<std::string, std::string> get_t;
|
||||
|
||||
put_t req1("put", "apple", "red");
|
||||
put_t req2("put", "lemon", "yellow");
|
||||
get_t req3("get", "apple");
|
||||
pk.pack(req1);
|
||||
pk.pack(req2);
|
||||
pk.pack(req3);
|
||||
writer.flush();
|
||||
writer.close();
|
||||
|
||||
pthread_join(thread, NULL);
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
|
||||
INCLUDE_DIRECTORIES (
|
||||
../include
|
||||
)
|
||||
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
container.cpp
|
||||
non_def_con_class.cpp
|
||||
)
|
||||
|
||||
IF ("${MSGPACK_DEFAULT_API_VERSION}" GREATER "1")
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
socket_stream_example.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
|
||||
FOREACH (source_file ${exec_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
ENDIF ()
|
||||
@ -1,158 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
#include <array>
|
||||
#include <tuple>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <forward_list>
|
||||
#include <string>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
void array() {
|
||||
std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, a);
|
||||
|
||||
msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
|
||||
msgpack::object obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert((obj.as<std::array<int, 5>>()) == a);
|
||||
}
|
||||
|
||||
void tuple() {
|
||||
std::tuple<bool, std::string, int> t(true, "ABC", 42);
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, t);
|
||||
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size());
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(t)>() == t);
|
||||
}
|
||||
|
||||
void unordered_map() {
|
||||
std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, m);
|
||||
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size());
|
||||
msgpack::object obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(m)>() == m);
|
||||
}
|
||||
|
||||
void unordered_set() {
|
||||
std::unordered_set<std::string> s { "ABC", "DEF" };
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, s);
|
||||
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size());
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(s)>() == s);
|
||||
}
|
||||
|
||||
void forward_list() {
|
||||
using type = std::forward_list<std::string>;
|
||||
type f { "ABC", "DEF" };
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, f);
|
||||
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size());
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<type>() == f);
|
||||
}
|
||||
|
||||
void combi() {
|
||||
std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
|
||||
std::tuple<bool, std::string, int> t {true, "ABC", 42};
|
||||
std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
|
||||
std::unordered_set<std::string> s { "ABC", "DEF" };
|
||||
std::forward_list<std::string> f { "ABC", "DEF" };
|
||||
|
||||
std::stringstream ss;
|
||||
msgpack::pack(ss, a);
|
||||
msgpack::pack(ss, t);
|
||||
msgpack::pack(ss, m);
|
||||
msgpack::pack(ss, s);
|
||||
msgpack::pack(ss, f);
|
||||
|
||||
std::size_t offset = 0;
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
{
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size(), offset);
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(a)>() == a);
|
||||
}
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
{
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size(), offset);
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(t)>() == t);
|
||||
}
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
{
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size(), offset);
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(m)>() == m);
|
||||
}
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
{
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size(), offset);
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(s)>() == s);
|
||||
}
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
{
|
||||
auto const& str = ss.str();
|
||||
auto oh = msgpack::unpack(str.data(), str.size(), offset);
|
||||
auto obj = oh.get();
|
||||
|
||||
std::cout << obj << std::endl;
|
||||
assert(obj.as<decltype(f)>() == f);
|
||||
}
|
||||
std::cout << "offset: " << offset << std::endl;
|
||||
}
|
||||
|
||||
int main() {
|
||||
array();
|
||||
tuple();
|
||||
unordered_map();
|
||||
unordered_set();
|
||||
forward_list();
|
||||
combi();
|
||||
}
|
||||
@ -1,51 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct my {
|
||||
my() = delete;
|
||||
|
||||
// target class should be either copyable or movable (or both).
|
||||
my(my const&) = delete;
|
||||
my(my&&) = default;
|
||||
|
||||
my(int a):a(a) {}
|
||||
int a;
|
||||
MSGPACK_DEFINE(a);
|
||||
};
|
||||
|
||||
namespace msgpack {
|
||||
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
|
||||
namespace adaptor {
|
||||
|
||||
template<>
|
||||
struct as<my> {
|
||||
my operator()(msgpack::object const& o) const {
|
||||
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
|
||||
if (o.via.array.size != 1) throw msgpack::type_error();
|
||||
return my(o.via.array.ptr[0].as<int>());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace adaptor
|
||||
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
|
||||
} // namespace msgpack
|
||||
|
||||
int main() {
|
||||
my m1(42);
|
||||
msgpack::zone z;
|
||||
msgpack::object obj(m1, z);
|
||||
std::cout << obj << std::endl;
|
||||
assert(m1.a == obj.as<my>().a);
|
||||
}
|
||||
@ -1,157 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct json_like_visitor : msgpack::v2::null_visitor {
|
||||
json_like_visitor(std::string& s):m_s(s), m_ref(false) {} // m_ref is false by default
|
||||
|
||||
bool visit_nil() {
|
||||
m_s += "null";
|
||||
return true;
|
||||
}
|
||||
bool visit_boolean(bool v) {
|
||||
if (v) m_s += "true";
|
||||
else m_s += "false";
|
||||
return true;
|
||||
}
|
||||
bool visit_positive_integer(uint64_t v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_negative_integer(int64_t v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_str(const char* v, uint32_t size) {
|
||||
// I omit escape process.
|
||||
m_s += '"' + std::string(v, size) + '"';
|
||||
return true;
|
||||
}
|
||||
bool start_array(uint32_t /*num_elements*/) {
|
||||
m_s += "[";
|
||||
return true;
|
||||
}
|
||||
bool end_array_item() {
|
||||
m_s += ",";
|
||||
return true;
|
||||
}
|
||||
bool end_array() {
|
||||
m_s.erase(m_s.size() - 1, 1); // remove the last ','
|
||||
m_s += "]";
|
||||
return true;
|
||||
}
|
||||
bool start_map(uint32_t /*num_kv_pairs*/) {
|
||||
m_s += "{";
|
||||
return true;
|
||||
}
|
||||
bool end_map_key() {
|
||||
m_s += ":";
|
||||
return true;
|
||||
}
|
||||
bool end_map_value() {
|
||||
m_s += ",";
|
||||
return true;
|
||||
}
|
||||
bool end_map() {
|
||||
m_s.erase(m_s.size() - 1, 1); // remove the last ','
|
||||
m_s += "}";
|
||||
return true;
|
||||
}
|
||||
void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
|
||||
std::cerr << "parse error"<<std::endl;
|
||||
}
|
||||
void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
|
||||
std::cout << "insufficient bytes"<<std::endl;
|
||||
}
|
||||
std::string& m_s;
|
||||
|
||||
// These two functions are required by parser.
|
||||
void set_referenced(bool ref) { m_ref = ref; }
|
||||
bool referenced() const { return m_ref; }
|
||||
bool m_ref;
|
||||
};
|
||||
|
||||
struct do_nothing {
|
||||
void operator()(char* /*buffer*/) {
|
||||
}
|
||||
};
|
||||
|
||||
class json_like_printer : public msgpack::parser<json_like_printer, do_nothing>,
|
||||
public json_like_visitor {
|
||||
typedef parser<json_like_printer, do_nothing> parser_t;
|
||||
public:
|
||||
json_like_printer(std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE)
|
||||
:parser_t(do_nothing_, initial_buffer_size),
|
||||
json_like_visitor(json_str_) {
|
||||
}
|
||||
|
||||
json_like_visitor& visitor() { return *this; }
|
||||
void print() { std::cout << json_str_ << std::endl; json_str_.clear();}
|
||||
private:
|
||||
do_nothing do_nothing_;
|
||||
std::string json_str_;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct ref_buffer {
|
||||
ref_buffer(T& t):t(t) {}
|
||||
void write(char const* ptr, std::size_t len) {
|
||||
if (len > t.buffer_capacity()) {
|
||||
t.reserve_buffer(len - t.buffer_capacity());
|
||||
}
|
||||
std::memcpy(t.buffer(), ptr, len);
|
||||
t.buffer_consumed(len);
|
||||
}
|
||||
T& t;
|
||||
};
|
||||
|
||||
#define BUFFERING_SIZE_MAX 100
|
||||
|
||||
//simulates streamed content (a socket for example)
|
||||
bool produce( std::stringstream & ss, char* buff, std::size_t& size)
|
||||
{
|
||||
ss.read(buff, BUFFERING_SIZE_MAX);
|
||||
size = static_cast<std::size_t>(ss.gcount());
|
||||
return (size > 0);
|
||||
}
|
||||
|
||||
//shows how you can treat data
|
||||
void consume( const char* buff, const std::size_t size,
|
||||
ref_buffer<json_like_printer> & rb,
|
||||
json_like_printer & jp
|
||||
)
|
||||
{
|
||||
rb.write(buff,size);
|
||||
while( jp.next() )
|
||||
{
|
||||
//here we print the data, you could do any wanted processing
|
||||
jp.print();
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
||||
std::vector<std::vector<int>> vvi1 { { 1,2,3,4,5}, { 6,7,8,9,10} };
|
||||
std::vector<std::vector<int>> vvi2 { { 11,12,13,14,15}, { 16,17,18,19,20} };
|
||||
|
||||
std::stringstream ss;
|
||||
|
||||
msgpack::pack(ss, vvi1);
|
||||
msgpack::pack(ss, vvi2);
|
||||
|
||||
char buffer[BUFFERING_SIZE_MAX];
|
||||
std::size_t size = 0;
|
||||
|
||||
json_like_printer jp(1); // set initial buffer size explicitly
|
||||
ref_buffer<json_like_printer> rb(jp);
|
||||
|
||||
while( produce(ss,buffer,size) )
|
||||
{
|
||||
consume(buffer, size, rb, jp);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,72 +0,0 @@
|
||||
IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
|
||||
INCLUDE_DIRECTORIES (
|
||||
../include
|
||||
)
|
||||
|
||||
LIST (APPEND exec_PROGRAMS
|
||||
unpack.cpp
|
||||
parse.cpp
|
||||
)
|
||||
IF (MSGPACK_BOOST)
|
||||
LIST (APPEND with_boost_PROGRAMS
|
||||
stream_unpack.cpp
|
||||
)
|
||||
ENDIF ()
|
||||
FOREACH (source_file ${exec_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
FOREACH (source_file ${with_boost_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_INCLUDE_DIRECTORIES (${source_file_we}
|
||||
PRIVATE
|
||||
$<TARGET_PROPERTY:msgpackc-cxx,INTERFACE_INCLUDE_DIRECTORIES>
|
||||
)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
${Boost_CONTEXT_LIBRARY}
|
||||
${Boost_SYSTEM_LIBRARY}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
|
||||
ENDIF ()
|
||||
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
|
||||
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
ELSE ()
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
ENDFOREACH ()
|
||||
ENDIF ()
|
||||
@ -1,125 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2017 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)
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
|
||||
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
struct json_like_visitor : msgpack::v2::null_visitor {
|
||||
json_like_visitor(std::string& s):m_s(s) {}
|
||||
|
||||
bool visit_nil() {
|
||||
m_s += "null";
|
||||
return true;
|
||||
}
|
||||
bool visit_boolean(bool v) {
|
||||
if (v) m_s += "true";
|
||||
else m_s += "false";
|
||||
return true;
|
||||
}
|
||||
bool visit_positive_integer(uint64_t v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_negative_integer(int64_t v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_float32(float v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_float64(double v) {
|
||||
std::stringstream ss;
|
||||
ss << v;
|
||||
m_s += ss.str();
|
||||
return true;
|
||||
}
|
||||
bool visit_str(const char* v, uint32_t size) {
|
||||
m_s += '"' + std::string(v, size) + '"';
|
||||
return true;
|
||||
}
|
||||
bool start_array(uint32_t /*num_elements*/) {
|
||||
m_s += "[";
|
||||
return true;
|
||||
}
|
||||
bool end_array_item() {
|
||||
m_s += ",";
|
||||
return true;
|
||||
}
|
||||
bool end_array() {
|
||||
m_s.erase(m_s.size() - 1, 1); // remove the last ','
|
||||
m_s += "]";
|
||||
return true;
|
||||
}
|
||||
bool start_map(uint32_t /*num_kv_pairs*/) {
|
||||
m_s += "{";
|
||||
return true;
|
||||
}
|
||||
bool end_map_key() {
|
||||
m_s += ":";
|
||||
return true;
|
||||
}
|
||||
bool end_map_value() {
|
||||
m_s += ",";
|
||||
return true;
|
||||
}
|
||||
bool end_map() {
|
||||
m_s.erase(m_s.size() - 1, 1); // remove the last ','
|
||||
m_s += "}";
|
||||
return true;
|
||||
}
|
||||
void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
|
||||
}
|
||||
void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
|
||||
}
|
||||
std::string& m_s;
|
||||
};
|
||||
|
||||
int main() {
|
||||
std::stringstream ss;
|
||||
std::map<std::string, std::vector<int>> v1 {
|
||||
{ "ABC", { 1, 2, 3 } },
|
||||
{ "DEFG", { 4, 5 } }
|
||||
};
|
||||
std::vector<std::string> v2 {
|
||||
"HIJ", "KLM", "NOP"
|
||||
};
|
||||
msgpack::pack(ss, v1);
|
||||
msgpack::pack(ss, v2);
|
||||
|
||||
std::string const& buf = ss.str();
|
||||
auto it = buf.begin();
|
||||
auto end = buf.end();
|
||||
{
|
||||
std::string str;
|
||||
bool ret = msgpack::parse(it, end, json_like_visitor(str));
|
||||
// it is updated here.
|
||||
assert(ret);
|
||||
std::cout << str << std::endl;
|
||||
}
|
||||
{
|
||||
std::string str;
|
||||
bool ret = msgpack::parse(it, end, json_like_visitor(str));
|
||||
// it is updated here.
|
||||
assert(ret);
|
||||
std::cout << str << std::endl;
|
||||
}
|
||||
}
|
||||
@ -1,248 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2017 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)
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
#include <thread>
|
||||
|
||||
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
|
||||
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
|
||||
|
||||
//#define MSGPACK_USE_X3_PARSE
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
#include <boost/coroutine2/all.hpp>
|
||||
|
||||
#if defined(__clang__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#endif // defined(__clang__)
|
||||
|
||||
#include <boost/spirit/home/support/multi_pass.hpp>
|
||||
|
||||
#if defined(__clang__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif // defined(__clang__)
|
||||
|
||||
namespace as = boost::asio;
|
||||
namespace x3 = boost::spirit::x3;
|
||||
namespace coro2 = boost::coroutines2;
|
||||
|
||||
using pull_type = coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::pull_type;
|
||||
|
||||
// iterator fetching data from coroutine2.
|
||||
class buffered_iterator : public std::iterator<std::input_iterator_tag, char> {
|
||||
public:
|
||||
using pointer_t = typename iterator::pointer;
|
||||
using reference_t = typename iterator::reference;
|
||||
|
||||
explicit buffered_iterator(pull_type& source) noexcept
|
||||
: source_{ &source } {
|
||||
fetch_();
|
||||
}
|
||||
buffered_iterator() = default;
|
||||
|
||||
bool operator==(buffered_iterator const& other) const noexcept {
|
||||
if (!other.source_ && !source_ && !other.buf_ && !buf_) return true;
|
||||
return other.it_ == it_;
|
||||
}
|
||||
|
||||
bool operator!=(buffered_iterator const& other) const noexcept {
|
||||
return !(other == *this);
|
||||
}
|
||||
|
||||
buffered_iterator & operator++() {
|
||||
increment_();
|
||||
return * this;
|
||||
}
|
||||
|
||||
buffered_iterator operator++(int) = delete;
|
||||
|
||||
reference_t operator*() noexcept {
|
||||
return *it_;
|
||||
}
|
||||
|
||||
pointer_t operator->() noexcept {
|
||||
return std::addressof(*it_);
|
||||
}
|
||||
|
||||
private:
|
||||
void fetch_() noexcept {
|
||||
BOOST_ASSERT( nullptr != source_);
|
||||
if (*source_) {
|
||||
buf_ = source_->get();
|
||||
it_ = buf_->begin();
|
||||
}
|
||||
else {
|
||||
source_ = nullptr;
|
||||
buf_.reset();
|
||||
}
|
||||
}
|
||||
|
||||
void increment_() {
|
||||
BOOST_ASSERT( nullptr != source_);
|
||||
BOOST_ASSERT(*source_);
|
||||
if (++it_ == buf_->end()) {
|
||||
(*source_)();
|
||||
fetch_();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
pull_type* source_{ nullptr };
|
||||
std::shared_ptr<std::vector<char>> buf_;
|
||||
std::vector<char>::iterator it_;
|
||||
};
|
||||
|
||||
// session class that corresponding to each client
|
||||
class session : public std::enable_shared_from_this<session> {
|
||||
public:
|
||||
session(as::ip::tcp::socket socket)
|
||||
: socket_(std::move(socket)) {
|
||||
}
|
||||
|
||||
void start() {
|
||||
sink_ = std::make_shared<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type>(
|
||||
[&, this](pull_type& source) {
|
||||
// *1 is started when the first sink is called.
|
||||
|
||||
std::cout << "session started" << std::endl;
|
||||
do_read();
|
||||
source();
|
||||
|
||||
// use buffered_iterator here
|
||||
// b is incremented in msgpack::unpack() and fetch data from sink
|
||||
// via coroutine2 mechanism
|
||||
auto b = boost::spirit::make_default_multi_pass(buffered_iterator(source));
|
||||
auto e = boost::spirit::make_default_multi_pass(buffered_iterator());
|
||||
|
||||
// This is usually an infinity look, but for test, loop is finished when
|
||||
// two message pack data is processed.
|
||||
for (int i = 0; i != 2; ++i) {
|
||||
auto oh = msgpack::unpack(b, e);
|
||||
std::cout << oh.get() << std::endl;
|
||||
}
|
||||
}
|
||||
);
|
||||
// send dummy data to start *1
|
||||
(*sink_)({});
|
||||
}
|
||||
|
||||
private:
|
||||
void do_read() {
|
||||
std::cout << "session do_read() is called" << std::endl;
|
||||
auto self(shared_from_this());
|
||||
auto data = std::make_shared<std::vector<char>>(static_cast<std::size_t>(max_length));
|
||||
socket_.async_read_some(
|
||||
boost::asio::buffer(*data),
|
||||
[this, self, data]
|
||||
(boost::system::error_code ec, std::size_t length) {
|
||||
if (!ec) {
|
||||
data->resize(length);
|
||||
(*sink_)(data);
|
||||
do_read();
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
as::ip::tcp::socket socket_;
|
||||
static constexpr std::size_t const max_length = 1024;
|
||||
std::shared_ptr<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type> sink_;
|
||||
};
|
||||
|
||||
class server {
|
||||
public:
|
||||
server(
|
||||
as::io_service& ios,
|
||||
std::uint16_t port)
|
||||
: acceptor_(ios, as::ip::tcp::endpoint(as::ip::tcp::v4(), port)),
|
||||
socket_(ios) {
|
||||
do_accept();
|
||||
std::cout << "server start accept" << std::endl;
|
||||
ios.run();
|
||||
}
|
||||
|
||||
private:
|
||||
void do_accept() {
|
||||
acceptor_.async_accept(
|
||||
socket_,
|
||||
[this](boost::system::error_code ec) {
|
||||
if (!ec) {
|
||||
std::make_shared<session>(std::move(socket_))->start();
|
||||
}
|
||||
// for test, only one session is accepted.
|
||||
// do_accept();
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
as::ip::tcp::acceptor acceptor_;
|
||||
as::ip::tcp::socket socket_;
|
||||
};
|
||||
|
||||
int main() {
|
||||
std::thread srv(
|
||||
[]{
|
||||
boost::asio::io_service ios;
|
||||
server s(ios, 12345);
|
||||
}
|
||||
);
|
||||
|
||||
std::thread cli(
|
||||
[]{
|
||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||
std::cout << "client start" << std::endl;
|
||||
|
||||
std::stringstream ss;
|
||||
std::map<std::string, std::vector<int>> v1 {
|
||||
{ "ABC", { 1, 2, 3 } },
|
||||
{ "DEFG", { 4, 5 } }
|
||||
};
|
||||
std::vector<std::string> v2 {
|
||||
"HIJ", "KLM", "NOP"
|
||||
};
|
||||
msgpack::pack(ss, v1);
|
||||
msgpack::pack(ss, v2);
|
||||
|
||||
auto send_data = ss.str();
|
||||
|
||||
boost::asio::io_service ios;
|
||||
as::ip::tcp::resolver::query q("127.0.0.1", "12345");
|
||||
as::ip::tcp::resolver r(ios);
|
||||
auto it = r.resolve(q);
|
||||
|
||||
std::cout << "client connect" << std::endl;
|
||||
as::ip::tcp::socket s(ios);
|
||||
as::connect(s, it);
|
||||
|
||||
|
||||
std::size_t const size = 5;
|
||||
std::size_t rest = send_data.size();
|
||||
std::size_t index = 0;
|
||||
while (rest != 0) {
|
||||
std::cout << "client send data" << std::endl;
|
||||
auto send_size = size < rest ? size : rest;
|
||||
as::write(s, as::buffer(&send_data[index], send_size));
|
||||
rest -= send_size;
|
||||
index += send_size;
|
||||
std::cout << "client wait" << std::endl;
|
||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
cli.join();
|
||||
std::cout << "client joinded" << std::endl;
|
||||
srv.join();
|
||||
std::cout << "server joinded" << std::endl;
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
// MessagePack for C++ example
|
||||
//
|
||||
// Copyright (C) 2017 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)
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
|
||||
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
|
||||
|
||||
#include <msgpack.hpp>
|
||||
|
||||
int main() {
|
||||
std::stringstream ss;
|
||||
std::map<std::string, std::vector<int>> v1 {
|
||||
{ "ABC", { 1, 2, 3 } },
|
||||
{ "DEFG", { 4, 5 } }
|
||||
};
|
||||
std::vector<std::string> v2 {
|
||||
"HIJ", "KLM", "NOP"
|
||||
};
|
||||
msgpack::pack(ss, v1);
|
||||
msgpack::pack(ss, v2);
|
||||
|
||||
std::string const& buf = ss.str();
|
||||
auto it = buf.begin();
|
||||
auto end = buf.end();
|
||||
{
|
||||
auto oh = msgpack::unpack(it, end);
|
||||
// it is updated here.
|
||||
assert(v1 == (oh.get().as<std::map<std::string, std::vector<int>>>()));
|
||||
}
|
||||
{
|
||||
auto oh = msgpack::unpack(it, end);
|
||||
assert(v2 == oh.get().as<std::vector<std::string>>());
|
||||
}
|
||||
}
|
||||
1
external/boost/predef
vendored
1
external/boost/predef
vendored
@ -1 +0,0 @@
|
||||
Subproject commit 560ff5298ead78276872604f1ee6523e63a4fa90
|
||||
1
external/boost/preprocessor
vendored
1
external/boost/preprocessor
vendored
@ -1 +0,0 @@
|
||||
Subproject commit 56090c56b5c78418b6dbe8c3c2ba576395152f83
|
||||
@ -1,43 +0,0 @@
|
||||
FIND_PACKAGE (GTest REQUIRED)
|
||||
FIND_PACKAGE (ZLIB REQUIRED)
|
||||
FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem)
|
||||
|
||||
INCLUDE_DIRECTORIES (
|
||||
${GTEST_INCLUDE_DIRS}
|
||||
${ZLIB_INCLUDE_DIRS}
|
||||
${Boost_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
LIST (APPEND check_PROGRAMS
|
||||
regression_runner.cpp
|
||||
)
|
||||
|
||||
LINK_DIRECTORIES (
|
||||
${Boost_LIBRARY_DIRS}
|
||||
)
|
||||
|
||||
FOREACH (source_file ${check_PROGRAMS})
|
||||
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
|
||||
ADD_EXECUTABLE (
|
||||
${source_file_we}
|
||||
${source_file}
|
||||
)
|
||||
TARGET_LINK_LIBRARIES (${source_file_we}
|
||||
msgpackc
|
||||
${GTEST_BOTH_LIBRARIES}
|
||||
${ZLIB_LIBRARIES}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
${Boost_LIBRARIES}
|
||||
)
|
||||
ADD_TEST (${source_file_we} ${source_file_we})
|
||||
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -g")
|
||||
IF ("${MSGPACK_SAN}" STREQUAL "ASAN")
|
||||
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
|
||||
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
|
||||
ELSEIF ("${MSGPACK_SAN}" STREQUAL "UBSAN")
|
||||
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
|
||||
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
|
||||
ENDIF()
|
||||
ENDIF()
|
||||
ENDFOREACH ()
|
||||
@ -1,50 +0,0 @@
|
||||
#include <boost/filesystem.hpp>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
#include "unpack_pack_fuzzer.cpp"
|
||||
|
||||
using ::testing::TestWithParam;
|
||||
using ::testing::ValuesIn;
|
||||
|
||||
|
||||
std::vector<std::string> ListDirectory(const std::string& path) {
|
||||
std::vector<std::string> v;
|
||||
|
||||
boost::filesystem::path p(path);
|
||||
boost::filesystem::directory_iterator f{p};
|
||||
|
||||
if(boost::filesystem::is_directory(p)) {
|
||||
while (f != boost::filesystem::directory_iterator{}) {
|
||||
v.push_back((*f++).path().string());
|
||||
}
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
class UnpackPackFuzzerRegressionTest : public ::testing::TestWithParam<std::string> {
|
||||
public:
|
||||
};
|
||||
|
||||
TEST_P(UnpackPackFuzzerRegressionTest, Returns0) {
|
||||
auto fpath = GetParam();
|
||||
std::ifstream in(fpath, std::ifstream::binary);
|
||||
if (!in) {
|
||||
FAIL() << fpath << " not found";
|
||||
}
|
||||
in.seekg(0, in.end);
|
||||
size_t length = in.tellg();
|
||||
in.seekg(0, in.beg);
|
||||
std::vector<char> bytes(length);
|
||||
in.read(bytes.data(), bytes.size());
|
||||
assert(in);
|
||||
EXPECT_EQ(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
|
||||
bytes.size()));
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(UnpackPackFuzzerRegressions,
|
||||
UnpackPackFuzzerRegressionTest,
|
||||
::testing::ValuesIn(ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions")));
|
||||
@ -1,23 +0,0 @@
|
||||
#include <msgpack.hpp>
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
try {
|
||||
// NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
|
||||
// setting these at far smaller values to avoid OOMs
|
||||
const int test_limit = 1000;
|
||||
msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
|
||||
size,
|
||||
nullptr,
|
||||
nullptr,
|
||||
msgpack::unpack_limit(test_limit,
|
||||
test_limit,
|
||||
test_limit,
|
||||
test_limit,
|
||||
test_limit,
|
||||
test_limit));
|
||||
msgpack::sbuffer sbuf;
|
||||
msgpack::pack(sbuf, unpacked.get());
|
||||
} catch (...) {
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
@ -1 +0,0 @@
|
||||
<EFBFBD>
|
||||
@ -1 +0,0 @@
|
||||
<EFBFBD>
|
||||
@ -1,2 +0,0 @@
|
||||
’’’’’’’’’ ’
|
||||
’ ’ ’
’’’’’’’’’’’’’’’ ’ ’ ’ ’ ’!’"’#’$’%’&’'’(’)’*’+’,’-’.’/’0’1’2’3’4’5’6’7’8’9’:’;’<’=’>’?’@’A’B’C’D’E’F’G’H’I’J’K’L’M’N’O’P’Q’R’S’T’U’V’W’X’Y’Z’[’\’]’^’_’`’a’b’c’d’e’f’g’h’i’j’k’l’m’n’o’p’q’r’s’t’u’v’w‘x
|
||||
Binary file not shown.
Binary file not shown.
@ -1,22 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++
|
||||
//
|
||||
// Copyright (C) 2008-2009 FURUHASHI Sadayuki
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
#include "msgpack/object.hpp"
|
||||
#include "msgpack/iterator.hpp"
|
||||
#include "msgpack/zone.hpp"
|
||||
#include "msgpack/pack.hpp"
|
||||
#include "msgpack/null_visitor.hpp"
|
||||
#include "msgpack/parse.hpp"
|
||||
#include "msgpack/unpack.hpp"
|
||||
#include "msgpack/x3_parse.hpp"
|
||||
#include "msgpack/x3_unpack.hpp"
|
||||
#include "msgpack/sbuffer.hpp"
|
||||
#include "msgpack/vrefbuffer.hpp"
|
||||
#include "msgpack/version.hpp"
|
||||
#include "msgpack/type.hpp"
|
||||
@ -1,19 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2015-2016 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_ADAPTOR_BASE_HPP
|
||||
#define MSGPACK_ADAPTOR_BASE_HPP
|
||||
|
||||
#include "msgpack/adaptor/adaptor_base_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/adaptor_base.hpp"
|
||||
#include "msgpack/v2/adaptor/adaptor_base.hpp"
|
||||
#include "msgpack/v3/adaptor/adaptor_base.hpp"
|
||||
|
||||
#endif // MSGPACK_ADAPTOR_BASE_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_ADAPTOR_BASE_DECL_HPP
|
||||
#define MSGPACK_ADAPTOR_BASE_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/adaptor_base_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/adaptor_base_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/adaptor_base_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_ADAPTOR_BASE_DECL_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_TYPE_ARRAY_REF_HPP
|
||||
#define MSGPACK_TYPE_ARRAY_REF_HPP
|
||||
|
||||
#include "msgpack/adaptor/array_ref_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/array_ref.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_ARRAY_REFL_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_TYPE_ARRAY_REF_DECL_HPP
|
||||
#define MSGPACK_TYPE_ARRAY_REF_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/array_ref_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/array_ref_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/array_ref_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_TYPE_BOOL_HPP
|
||||
#define MSGPACK_TYPE_BOOL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/bool.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// 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_TYPE_BOOST_FUSION_HPP
|
||||
#define MSGPACK_TYPE_BOOST_FUSION_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/fusion.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_FUSION_HPP
|
||||
@ -1,18 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2015-2016 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_TYPE_BOOST_MSGPACK_VARIANT_HPP
|
||||
#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
|
||||
|
||||
#include "msgpack/adaptor/boost/msgpack_variant_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/msgpack_variant.hpp"
|
||||
//#include "msgpack/v2/adaptor/boost/msgpack_variant.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
|
||||
#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_BOOST_OPTIONAL_HPP
|
||||
#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/optional.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_BOOST_STRING_REF_HPP
|
||||
#define MSGPACK_TYPE_BOOST_STRING_REF_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/string_ref.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2017 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_TYPE_BOOST_STRING_VIEW_HPP
|
||||
#define MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/boost/string_view.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CARRAY_HPP
|
||||
#define MSGPACK_TYPE_CARRAY_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/carray.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CARRAY_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CHAR_PTR_HPP
|
||||
#define MSGPACK_TYPE_CHAR_PTR_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/char_ptr.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CHAR_PTR_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2015-2016 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_CHECK_CONTAINER_SIZE_HPP
|
||||
#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
|
||||
|
||||
#include "msgpack/adaptor/check_container_size_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/check_container_size.hpp"
|
||||
|
||||
#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_CHECK_CONTAINER_SIZE_DECL_HPP
|
||||
#define MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/check_container_size_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/check_container_size_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/check_container_size_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_ARRAY_HPP
|
||||
#define MSGPACK_TYPE_CPP11_ARRAY_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/array.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_ARRAY_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_ARRAY_CHAR_HPP
|
||||
#define MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/array_char.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
|
||||
#define MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2017 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_TYPE_CPP11_CHRONO_HPP
|
||||
#define MSGPACK_TYPE_CPP11_CHRONO_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/chrono.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_CHRONO_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_FORWARD_LIST_HPP
|
||||
#define MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/forward_list.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_REFERENCE_WRAPPER_HPP
|
||||
#define MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/reference_wrapper.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_SHARED_PTR_HPP
|
||||
#define MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/shared_ptr.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2019 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_TYPE_CPP11_TIMESPEC_HPP
|
||||
#define MSGPACK_TYPE_CPP11_TIMESPEC_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/timespec.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_TIMESPEC_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_TUPLE_HPP
|
||||
#define MSGPACK_TYPE_CPP11_TUPLE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/tuple.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_TUPLE_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_UNIQUE_PTR_HPP
|
||||
#define MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/unique_ptr.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_UNORDERED_MAP_HPP
|
||||
#define MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/unordered_map.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_CPP11_UNORDERED_SET_HPP
|
||||
#define MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp11/unordered_set.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2018 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_TYPE_CPP17_BYTE_HPP
|
||||
#define MSGPACK_TYPE_CPP17_BYTE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp17/byte.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP17_BYTE_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2018 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_TYPE_CPP17_CARRAY_BYTE_HPP
|
||||
#define MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp17/carray_byte.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2017 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_TYPE_CPP17_OPTIONAL_HPP
|
||||
#define MSGPACK_TYPE_CPP17_OPTIONAL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp17/optional.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP17_OPTIONAL_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2017 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_TYPE_CPP17_STRING_VIEW_HPP
|
||||
#define MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp17/string_view.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
|
||||
@ -1,16 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2018 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_TYPE_CPP17_VECTOR_BYTE_HPP
|
||||
#define MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/cpp17/vector_byte.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_DEFINE_HPP
|
||||
#define MSGPACK_DEFINE_HPP
|
||||
|
||||
#include "msgpack/adaptor/define_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/define.hpp"
|
||||
|
||||
#endif // MSGPACK_DEFINE_HPP
|
||||
@ -1,144 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_DEFINE_DECL_HPP
|
||||
#define MSGPACK_DEFINE_DECL_HPP
|
||||
|
||||
// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
|
||||
// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
|
||||
// However, supporting compiler detection is not complete. msgpack-c requires
|
||||
// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
|
||||
#if !defined(MSGPACK_PP_VARIADICS)
|
||||
#define MSGPACK_PP_VARIADICS
|
||||
#endif
|
||||
|
||||
#include <msgpack/preprocessor.hpp>
|
||||
|
||||
#include "msgpack/versioning.hpp"
|
||||
|
||||
// for MSGPACK_ADD_ENUM
|
||||
#include "msgpack/adaptor/int.hpp"
|
||||
|
||||
#define MSGPACK_DEFINE_ARRAY(...) \
|
||||
template <typename Packer> \
|
||||
void msgpack_pack(Packer& msgpack_pk) const \
|
||||
{ \
|
||||
msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(msgpack_pk); \
|
||||
} \
|
||||
void msgpack_unpack(msgpack::object const& msgpack_o) \
|
||||
{ \
|
||||
msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(msgpack_o); \
|
||||
}\
|
||||
template <typename MSGPACK_OBJECT> \
|
||||
void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \
|
||||
{ \
|
||||
msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(msgpack_o, msgpack_z); \
|
||||
}
|
||||
|
||||
#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
|
||||
#define MSGPACK_NVP(name, value) (name) (value)
|
||||
|
||||
#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
|
||||
MSGPACK_PP_IF( \
|
||||
MSGPACK_PP_IS_BEGIN_PARENS(elem), \
|
||||
elem, \
|
||||
(MSGPACK_PP_STRINGIZE(elem))(elem) \
|
||||
)
|
||||
|
||||
#define MSGPACK_DEFINE_MAP_IMPL(...) \
|
||||
MSGPACK_PP_SEQ_TO_TUPLE( \
|
||||
MSGPACK_PP_SEQ_FOR_EACH( \
|
||||
MSGPACK_DEFINE_MAP_EACH_PROC, \
|
||||
0, \
|
||||
MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
|
||||
) \
|
||||
)
|
||||
|
||||
#define MSGPACK_DEFINE_MAP(...) \
|
||||
template <typename Packer> \
|
||||
void msgpack_pack(Packer& msgpack_pk) const \
|
||||
{ \
|
||||
msgpack::type::make_define_map \
|
||||
MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
|
||||
.msgpack_pack(msgpack_pk); \
|
||||
} \
|
||||
void msgpack_unpack(msgpack::object const& msgpack_o) \
|
||||
{ \
|
||||
msgpack::type::make_define_map \
|
||||
MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
|
||||
.msgpack_unpack(msgpack_o); \
|
||||
}\
|
||||
template <typename MSGPACK_OBJECT> \
|
||||
void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \
|
||||
{ \
|
||||
msgpack::type::make_define_map \
|
||||
MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
|
||||
.msgpack_object(msgpack_o, msgpack_z); \
|
||||
}
|
||||
|
||||
#define MSGPACK_BASE_MAP(base) \
|
||||
(MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
|
||||
|
||||
// MSGPACK_ADD_ENUM must be used in the global namespace.
|
||||
#define MSGPACK_ADD_ENUM(enum_name) \
|
||||
namespace msgpack { \
|
||||
/** @cond */ \
|
||||
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { \
|
||||
/** @endcond */ \
|
||||
namespace adaptor { \
|
||||
template<> \
|
||||
struct convert<enum_name> { \
|
||||
msgpack::object const& operator()(msgpack::object const& msgpack_o, enum_name& msgpack_v) const { \
|
||||
msgpack::underlying_type<enum_name>::type tmp; \
|
||||
msgpack::operator>>(msgpack_o, tmp); \
|
||||
msgpack_v = static_cast<enum_name>(tmp); \
|
||||
return msgpack_o; \
|
||||
} \
|
||||
}; \
|
||||
template<> \
|
||||
struct object<enum_name> { \
|
||||
void operator()(msgpack::object& msgpack_o, const enum_name& msgpack_v) const { \
|
||||
msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v); \
|
||||
msgpack::operator<<(msgpack_o, tmp); \
|
||||
} \
|
||||
}; \
|
||||
template<> \
|
||||
struct object_with_zone<enum_name> { \
|
||||
void operator()(msgpack::object::with_zone& msgpack_o, const enum_name& msgpack_v) const { \
|
||||
msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v); \
|
||||
msgpack::operator<<(msgpack_o, tmp); \
|
||||
} \
|
||||
}; \
|
||||
template <> \
|
||||
struct pack<enum_name> { \
|
||||
template <typename Stream> \
|
||||
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& msgpack_o, const enum_name& msgpack_v) const { \
|
||||
return msgpack::operator<<(msgpack_o, static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v)); \
|
||||
} \
|
||||
}; \
|
||||
} \
|
||||
/** @cond */ \
|
||||
} \
|
||||
/** @endcond */ \
|
||||
}
|
||||
|
||||
#if defined(MSGPACK_USE_DEFINE_MAP)
|
||||
#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
|
||||
#define MSGPACK_BASE MSGPACK_BASE_MAP
|
||||
#else // defined(MSGPACK_USE_DEFINE_MAP)
|
||||
#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
|
||||
#define MSGPACK_BASE MSGPACK_BASE_ARRAY
|
||||
#endif // defined(MSGPACK_USE_DEFINE_MAP)
|
||||
|
||||
|
||||
#include "msgpack/v1/adaptor/define_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/define_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/define_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_DEFINE_DECL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_DEQUE_HPP
|
||||
#define MSGPACK_TYPE_DEQUE_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/deque.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_DEQUE_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// 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_TYPE_EXT_HPP
|
||||
#define MSGPACK_TYPE_EXT_HPP
|
||||
|
||||
#include "msgpack/adaptor/ext_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/ext.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_EXT_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_EXT_DECL_HPP
|
||||
#define MSGPACK_TYPE_EXT_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/ext_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/ext_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/ext_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_EXT_DECL_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_FIXINT_HPP
|
||||
#define MSGPACK_TYPE_FIXINT_HPP
|
||||
|
||||
#include "msgpack/adaptor/fixint_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/fixint.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_FIXINT_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_FIXINT_DECL_HPP
|
||||
#define MSGPACK_TYPE_FIXINT_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/fixint_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/fixint_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/fixint_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_FIXINT_DECL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_FLOAT_HPP
|
||||
#define MSGPACK_TYPE_FLOAT_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/float.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_FLOAT_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_INT_HPP
|
||||
#define MSGPACK_TYPE_INT_HPP
|
||||
|
||||
#include "msgpack/adaptor/int_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/int.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_INT_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_INT_DECL_HPP
|
||||
#define MSGPACK_TYPE_INT_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/int_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/int_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/int_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_INT_DECL_HPP
|
||||
@ -1,15 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_TYPE_LIST_HPP
|
||||
#define MSGPACK_TYPE_LIST_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/list.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_LIST_HPP
|
||||
@ -1,18 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_TYPE_MAP_HPP
|
||||
#define MSGPACK_TYPE_MAP_HPP
|
||||
|
||||
#include "msgpack/adaptor/map_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/map.hpp"
|
||||
|
||||
|
||||
#endif // MSGPACK_TYPE_MAP_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2016 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_TYPE_MAP_DECL_HPP
|
||||
#define MSGPACK_TYPE_MAP_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/map_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/map_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/map_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_TYPE_MAP_DECL_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2008-2014 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_MSGPACK_TUPLE_HPP
|
||||
#define MSGPACK_MSGPACK_TUPLE_HPP
|
||||
|
||||
#include "msgpack/adaptor/msgpack_tuple_decl.hpp"
|
||||
|
||||
#include "msgpack/v1/adaptor/msgpack_tuple.hpp"
|
||||
|
||||
#endif // MSGPACK_MSGPACK_TUPLE_HPP
|
||||
@ -1,17 +0,0 @@
|
||||
//
|
||||
// MessagePack for C++ static resolution routine
|
||||
//
|
||||
// Copyright (C) 2016 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_MSGPACK_TUPLE_DECL_HPP
|
||||
#define MSGPACK_MSGPACK_TUPLE_DECL_HPP
|
||||
|
||||
#include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
|
||||
#include "msgpack/v2/adaptor/msgpack_tuple_decl.hpp"
|
||||
#include "msgpack/v3/adaptor/msgpack_tuple_decl.hpp"
|
||||
|
||||
#endif // MSGPACK_MSGPACK_TUPLE_DECL_HPP
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user