Update issue templates

remove files in master for separating C and C++ libraries

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,19 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+msgpack-c or msgpack-cxx version.
+e.g) msgpack-cxx 5.0.0 
+
+**To Reproduce**
+Please prepare https://stackoverflow.com/help/minimal-reproducible-example
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.

.gitignore

@@ -1,51 +0,0 @@
-# Files generated by the bootstrap script.
-/INSTALL
-/AUTHORS
-/ChangeLog
-/NEWS
-/README
-/ac/
-/aclocal.m4
-/autom4te.cache/
-/config.h.in
-/configure
-/msgpack_vc2008.sln
-/msgpack_vc2008.vcproj
-Makefile.in
-
-# Files generated by the configure script.
-
-/config.h
-/config.log
-/config.status
-/libtool
-/msgpack.pc
-/src/msgpack/version.h
-/src/msgpack/version.hpp
-/stamp-h1
-Makefile
-.deps
-.libs
-
-# Files generated by make.
-*.o
-*.so
-*.lo
-*.la
-
-# Files generated by make check.
-# TODO: Replace these with something like /test/*_test
-/test/buffer
-/test/cases
-/test/convert
-/test/fixint
-/test/fixint_c
-/test/msgpack_test
-/test/msgpackc_test
-/test/object
-/test/pack_unpack
-/test/pack_unpack_c
-/test/streaming
-/test/streaming_c
-/test/version
-/test/zone

.travis.yml

@@ -1,34 +0,0 @@
-language: cpp
-cache:
-  - apt
-compiler:
-  - clang
-  - gcc
-before_install:
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo add-apt-repository -y ppa:h-rayflood/llvm
-  - sudo apt-get update -qq
-  - sudo apt-get update
-  - sudo apt-get install valgrind
-install:
-  - sudo apt-get install -qq gcc-4.8-multilib g++-4.8-multilib
-  - sudo apt-get install --allow-unauthenticated -qq clang-3.4
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
-  - sudo apt-get install -y lib32gcc1
-  - sudo apt-get install -y libc6-i386
-  - sudo apt-get install -y lib32z1-dev
-  - sudo apt-get install -y lib32stdc++6
-  - wget https://googletest.googlecode.com/files/gtest-1.7.0.zip
-  - unzip gtest-1.7.0.zip && cd gtest-1.7.0 && sudo cp -r include/gtest /usr/local/include && g++ src/gtest-all.cc -I. -Iinclude -c && g++ src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mv *.a /usr/local/lib && g++ -m32 src/gtest-all.cc -I. -Iinclude -c && g++ -m32 src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mkdir /usr/local/lib32 && sudo mv *.a /usr/local/lib32 && cd ..
-env:
-  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32"
-
-script:
-  - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH}

CHANGELOG.md

@@ -1,4 +1,345 @@
-2014-07-02 version 0.5.9:
+# 2020-06-05 version 3.3.0
+  * Add json example for C (#870)
+  * Add both header and body packing functions for C (#870)
+  * Set default ref_size and chunk_size to vrefbuffer (#865)
+  * Add examples (#861)
+  * Improve build system (#839, #842)
+  * Improve tests (#829)
+  * Improve documents (#828)
+  * Remove some warnings (#827, #851, #871)
+  * Improve CI environment (#824, #831, #833, #834, #846, #860, 874)
+
+# 2019-12-10 version 3.2.1
+  * Fix snprintf return value checking (#821)
+  * Remove some warnings (#819)
+  * Fix fbuffer result checking (#812)
+  * Fix temporary object handling (#807)
+  * Improve cmake support (#804)
+  * Fix invalid `int main` parameter (#800)
+  * Improve supporting platform (#797, #817)
+  * Fix ZLIB error handling (#795)
+  * Remove unused variable (#793)
+  * Improve integer overflow checking (#792)
+
+# 2019-05-27 version 3.2.0
+
+  * Fix invalid include (#783)
+  * Add timespec support (#781)
+  * Fix unchecked fnprintf on C (#780)
+  * Improve integer overflow checking on C (#776)
+  * Fix warnings on `-Wconversion` (#770, #777, #784)
+  * Fix invalid passed by value on aligned_zone_size_visitor (#764)
+  * Improve windows support (#757, #779)
+  * Fix msgpack::object size caluclation error (#754)
+  * Fix memory error on example code (#753)
+  * Fix redundant memory allocation on C (#747)
+  * Fix msgpack::type::tuple base class conversion (#743)
+
+# 2018-09-09 version 3.1.1
+
+  * Add force endian set functionality (#736)
+  * Fix vrefbuffer memory management problem (#733)
+  * Fix msvc specific problem (#731, #732)
+  * Update boost from 1.61.0 to 1.68.0 (#730)
+  * Fix msgpack_timestamp type mismatch bug (#726)
+
+# 2018-08-10 version 3.1.0
+
+  * Improve documents (#687, #718)
+  * Add fuzzer support (#689)
+  * Fix msgpack::object union member access bug (#694)
+  * Improve cross platform configuration (#704)
+  * Fix out of range dereference bug of EXT (#705)
+  * Add timestamp support. std::chrono::system_clock::time_point is mapped to TIMESTAMP (#706)
+  * Add minimal timestamp support for C. The type `msgpack_timestamp` and the function `msgpack_object_to_timestamp()` are introduced (#707)
+  * Improve MSGPACK_DEFINE family name confliction probability (#710)
+  * Add no static-library build option (BUILD_SHARED_LIBS=ON) (#713, #717, #722)
+  * Add header only cmake target (#721)
+  * Add `std::byte` adaptor (#719)
+  * Remove some warnings (#720)
+
+# 2018-05-12 version 3.0.1
+
+  * Add fuzz directory to release tar ball (#686)
+  * Add include file checking for X-Code (#683)
+
+# 2018-05-09 version 3.0.0
+
+## << breaking changes >>
+
+  * Change offset parameter updating rule. If parse error happens, offset is updated to the error position. (#639, #666)
+
+## << other updates >>
+
+  * Improve cross platform configuration (#655, #677)
+  * Improve build system (#647)
+  * Improve user class adaptor (#645, #673)
+  * Improve msgpack::object visitation logic (#676)
+  * Remove some warnings (#641, 659)
+  * Add `->` and `*` operators to object_handle (#635)
+  * Improve CI environment (#631, #634, #643, #657, #662, #668)
+  * Improve documents (#630, #661)
+  * Refactoring (#670)
+  * Add OSS-Fuzz support (#672, #674, #675, #678)
+
+# 2017-08-04 version 2.1.5
+  * Improve cross platform configuration (#624)
+  * Add boost asio examples (including zlib) (#610)
+  * Remove some warnings (#611)
+  * Fix unpack visitor to treat float32/64 correctly (#613)
+  * Improve documents (#616)
+  * Fix alignment problem on some platform (#617, #518)
+  * Fix conflict std::tuple, std::pair, and boost::fusion::sequence problem (#619)
+
+# 2017-08-03 version 2.1.4 (Invalid)
+  * See https://github.com/msgpack/msgpack-c/issues/623
+
+# 2017-06-15 version 2.1.3
+  * Improve build system (#603)
+  * Add C++17 adaptors `std::optional` and `std::string_view`. (#607, #608)
+  * Improve cross platform configuration (#601)
+  * Remove some warnings (#599, #602, #605)
+
+# 2017-06-07 version 2.1.2
+
+* Improve documents (#565)
+  * Fix empty map parse bug (#568)
+  * Improve build system (#569, #570, #572, #579, #591, #592)
+  * Remove some warnings (#574, #578, #586, #588)
+  * Improve cross platform configuration (#577, #582)
+  * Add cmake package config support (#580)
+  * Fix streaming unpack bug (#585)
+
+# 2017-02-04 version 2.1.1
+
+  * Fix unpacker's buffer management bug (#561)
+  * Add boost string_view adaptor (#558)
+  * Remove some warnings (#557, #559)
+  * Improve coding style (#556)
+
+# 2017-01-10 version 2.1.0
+
+## << breaking changes >>
+
+  * Fix object internal data type is float if msgpack format is float32 (#531)
+
+## << recommended changes >>
+
+  * Add `FLOAT64` type. Please use it instead of `DOUBLE` (#531)
+  * Add `FLOAT32` type. Please use it instead of `FLOAT` (#531)
+
+## << other updates >>
+
+  * Add iterator based parse/unpack function(experimental) (#553)
+  * Add `[[deprecated]]` attribute for C++14 (#552)
+  * Fix `msgpack_unpack()` return code (#548)
+  * Fix integer overflow (#547, #549, #550)
+  * Add example codes (#542)
+  * Add MSGPACK_NVP. You can use not only variable name but also any strings (#535)
+  * Fix and Improve build system (#532, #545)
+  * Fix `gcc_atomic.hpp` include path (#529, #530)
+  * Improve CI environment (#526)
+  * Improve documents (#524)
+  * Add msgpack_unpacker_next_with_size() function (#515)
+  * Fix `as()` applying condition (#511)
+  * Fix fbuffer write (#504)
+  * Add gcc bug workaround (#499)
+  * Improve object print (#497, #500, #505, #533)
+  * Remove some warnings (#495, #506, #508, #513, #528, #538, #545)
+
+# 2016-06-25 version 2.0.0
+
+## << breaking changes >>
+
+  * Removed autotools support. Use cmake instead (#476, #479)
+  * Removed pointer version of msgpack::unpack APIs. Use reference version instead (#453)
+  * Removed MSGPACK_DISABLE_LEGACY_CONVERT. msgpack::object::convert(T*) is removed by default. Use msgpack::object::convert(T&) instead (#451)
+  * Removed msgpacl::type::nil. Use nil_t or define MSGPACK_USE_LECACY_NIL (#444)
+  * Removed std::string to msgpack::object conversion (#434)
+
+## << recommended changes >>
+
+  * Replaced msgpack::unpacked with msgpack::object_handle. msgpack::unpacked is kept as a typedef of msgpack::object_handle. (#448)
+
+## << other updates >>
+
+  * Add strict size checking adaptor. Relaxed tuple conversion (#489)
+  * Fix and Improve example codes (#487)
+  * Add C++/CLI support for nullptr (#481)
+  * Update the boost libraries that are contained by msgpack-c (#475)
+  * Fix gcc_atomic.hpp location (#474)
+  * Add C-Style array support (#466, #488)
+  * Fix include file dependency (#464)
+  * Add a visitor version of unpack API (#461)
+  * Fix JSON string conversion from "nil" to "null" (#458)
+  * Fix and Improve build system (#455, #471, #473, #486, #491)
+  * Fix comments (#452)
+  * Fix unintentional msgpack::zone moving problem (#447)
+  * Fix operator>> and << for msgpack::object (#443)
+  * Fix C++03 msgpack::zone::clear() memory access violation bug (#441)
+  * Fix TARGET_OS_IPHONE checking (#436)
+  * Fix invalid front() call for empty container (#435)
+  * Fix compile error on g++6 (C++11 only) (#426, #430)
+  * Fix zone size expansion logic (#423)
+  * Fix wrong hader file dependency (#421)
+  * Fix msvc specific problem (#420)
+  * Add v2 API support (#415)
+
+# 2016-01-22 version 1.4.0
+
+## << recommended changes >>
+
+  * Define [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140), then `msgpack::type::nil` is replaced by with `msgpack::type::nil_t` (#408, #411, #412).
+    Replace `msgpack::type::nil` with `msgpack::type::nil_t` in client codes.
+    `msgpack::type::nil` will be removed on the version 2.0.0.
+  * Define [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140), then `msgpack::object::convert(T*)` is removed (#410).
+    Replace calling `msgpack::bojectconvert(T*)` with `msgpack::bojectconvert(T&)` in client codes as follows:
+
+    ```C++
+     int i;
+     obj.convert(&i); // before
+     ```
+
+    ```C++
+     int i;
+     obj.convert(i);  // after
+     ```
+
+    `msgpack::object::convert(T*)` will be removed on the version 2.0.0.
+
+Define the macros above as follows when you compile C++ codes that use msgpack-c:
+
+```
+g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT your_code.cpp
+
+```
+
+You can compile existing codes without defining macros above but I recommend defining them and updating your codes to fix the issues #408, #411, #412, #399, and #410. It is also a good preparation for the version 2.0.0.
+
+## << other updates >>
+
+  * Improve documents (#387, #407)
+  * Remove C++ version library (#394, #402)
+  * Add Doxyfile and ChangeLog to the distribution package (#397)
+  * Add signed/unsigned char test to travis-ci (#398)
+  * Remove some warnings (#400, #401, #409)
+  * Fix endian checking. (#404)
+
+# 2015-11-21 version 1.3.0
+
+  * Change the license from the Apache License Version 2.0 to the
+    Boost Software License, Version 1.0.(#386)
+  * Remove some warnings (#365)
+  * Add std::reference_wrapper support(#373, #384)
+  * Improve tests (#375, #378, #379, #380)
+  * Fix msvc specific problem (#376, #383)
+  * Fix typos (#381)
+
+# 2015-09-04 version 1.2.0
+
+## << breaking changes >>
+
+  * Change std::vector<unsigned char> and std::array<unsigned char>
+    mapped to BIN instead of ARRAY (#243)
+  * Remove redundant copy (#285)
+
+
+## << other updates >>
+
+  * Add array_ref to map to ARRAY (#243)
+  * Add variant type and adaptor (#349)
+  * Add object::convert_if_not_nil() (#357)
+  * Fix invalid offset update (#354)
+  * Add C++11 support on MSVC2015(#339, #347)
+  * Fix and Improve build system (#346, #350, #361, #363)
+  * Import Boost.Preprocessor as a part of msgpack-c (#312)
+  * Fix OSX with libc++ specific errors (#334, #362)
+  * Add customized containers support (#330)
+  * Add std::unique_ptr and std::shared_ptr support (#329)
+  * Add missing install files (#328)
+  * Add shared/static library switching option (#316)
+  * Improve no throw description on C++11 (#313)
+  * Import Boost.Predef as a part of msgpack-c (#312)
+  * Add map based serialize support (#306)
+  * Add Boost.Fusion support (#305)
+  * Add v4 format RAW support (#304)
+  * Fix zbuffer with empty string problem (#303)
+  * Add non default constructible class support (#302, #324, #327, #331, #332, #345)
+  * Add inline keyword to function (template) (#299)
+  * Add EXT type supporting classes (#292, #308)
+  * Fix raw_ref != comparison (#290)
+  * Add object deep copy (#288)
+  * Remove some warnings (#284, #322, #323, #335)
+  * Improve compiler version checking (#283)
+  * Add return value to object::convert() (#282)
+  * Improve move semantic support in C++11 (#279, #353)
+  * Add Boost.StringRef support (#278)
+  * Improve CI environment (#276, #294, #338)
+  * Add converting to JSON (#274, #301)
+  * Fix iOS specific problem (#270)
+  * Improve doxtgen document generation (#269)
+  * Add Boost.Optional support (#268)
+  * Fix msvc specific problem (#267, #295)
+  * Add base class serialization. (#265, #277)
+  * Add and improve examples. (#264, #310, #311, #341, #342, #344)
+  * Fix wiki URL. (#263)
+
+# 2015-04-03 version 1.1.0
+
+## << breaking changes >>
+
+  * Remove msgpack_fwd.hpp
+  * Improve user types adaptation mechanism (#262)
+    Since version 1.0.0, users need to obey the correct include order.
+    However, it is very difficult to maintain the correct order in big
+    projects. version 1.1.0 removed this order. Users don't need to
+    care about include order. Migration guide from 1.0.x to 1.1.0 has
+    been written. See https://github.com/msgpack/msgpack-c/wiki
+
+
+## << other updates >>
+
+  * Fix vector<bool> size check (#251)
+  * Fix inttypes.h inclusion on MSVC (#257)
+  * Support documents generation by Doxygen (#259)
+  * Remove C99 style variable declaration (#253)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+
+# 2015-03-22 version 1.0.1:
+
+  * Fix compilation error on Mac 10.9 (#244)
+  * Fix typos in documents (#240)
+  * Update CHANGELOG.md for version 1.0.0 (#242)
+  * Fix erb templates for the next code generation (#239)
+
+# 2015-03-10 version 1.0.0:
+
+  * Support msgpack v5 format (str, bin, and ext) https://github.com/msgpack/msgpack/blob/master/spec.md (#142)
+  * Support std::tuple, std::forward_list, std::array, std::unordered_set, std::unordered_map on C++11. tr1 unordered containers are still supported (#53, #130, #137, #154, #169)
+  * Update msgpack-c as a header-only library on C++ (#142)
+  * Move include directory (#142)
+  * Update the name of float format family on msgpack::object from 'dec' to 'f64' (#194)
+  * Remove existing elements on associative containers when unpacking (#127)
+  * Add an API versioning functionality https://github.com/msgpack/msgpack-c/wiki/cpp_versioning (#139)
+  * Add C++11 enum class support (#205)
+  * Map std::vector<char> and std::array<char> to BIN (#100)
+  * Map '\0' teminated char* and char const* to STR (#206)
+  * Add the new parameter on unpacking functions and classes to limit msgpack's bytestream size (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#limit-size-of-elements) (#175)
+  * Add the copy or reference choosing function on unpack() and unpacker (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#memory-management)
+  * Add the new unpack() overloads for C++11 https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker (#128)
+  * Add a msgpack::object::with_zone (deep) copying function (#133, #163)
+  * Remove the compile-time defined limit of msgpack nest level on C++ (#218)
+  * Add the new unpack() overloads that use an existing zone (#201)
+  * Add the range-based for loop support on msgpack object array and map (#203)
+  * Add msgpack revision getter function for 'revision' (#237)
+  * Support EXT for C (#118, #129)
+  * Fix unpacking buffer allocation problem when malformed data is given (#160, #185)
+  * Add dll exporting function on MSVC (#162)
+  * Fix msgpack::zone::allocate_no_align(). Now it allocates the memory that is not aligned as expected (#171)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+  * Other bug fixes and refactoring: #62, #91, #95, #97, #107, #109, #113, #117, #119, #121, #122, #123, #126, #131, #136, #138, #140, #143, #145, #146, #150, #151, #152, #156, #157, #158, #161, #165, #170, #172, #179, #180, #181, #182, #183, #192, #195, #199, #200, #207, #211, #212, #219, #222, #224, #230, #231, #232, #233, #234, #235
+
+# 2014-07-02 version 0.5.9:
 
   * Support std::tr1 unordered containers by default (#51, #63, #68, #69)
   * Remove some warnings (#56)
@@ -12,7 +353,7 @@
   * Add FILE* buffer (#40)
   * Other bug fixes and refactoring: #39, #73, #77, #79, #80, #81, #84, #90
 
-2013-12-23 version 0.5.8:
+# 2013-12-23 version 0.5.8:
 
   * Move to the new github repository msgpack/msgpack-c
   * Support the new deserialization specification
@@ -20,38 +361,38 @@
   * Other bug fixes and refactoring: #46, #41, #36, #35, #33, #32, #30, #29, #28, #27, #26, #25, #8, #3
   * Update of documents: #23, #18, #17
 
-2011-08-08 version 0.5.7:
+# 2011-08-08 version 0.5.7:
 
   * fixes compile error problem with llvm-gcc and Mac OS X Lion
 
-2011-04-24 version 0.5.6:
+# 2011-04-24 version 0.5.6:
 
   * #42 fixes double-free problem on msgpack_unpacker_release_zone
 
-2011-02-24 version 0.5.5:
+# 2011-02-24 version 0.5.5:
 
   * eliminates dependency of winsock2.h header
   * fixes msgpack_vc.postbuild.bat file
   * fixes some implicit cast warnings
 
-2010-08-29 version 0.5.4:
+# 2010-08-29 version 0.5.4:
 
   * includes msgpack_vc2008.vcproj file in source package
   * fixes type::fix_int types
 
-2010-08-27 version 0.5.3:
+# 2010-08-27 version 0.5.3:
 
   * adds type::fix_{u,}int{8,16,32,64} types
   * adds msgpack_pack_fix_{u,}int{8,16,32,64} functions
   * adds packer<Stream>::pack_fix_{u,}int{8,16,32,64} functions
   * fixes include paths
 
-2010-07-14 version 0.5.2:
+# 2010-07-14 version 0.5.2:
 
   * type::raw::str(), operator==, operator!=, operator< and operator> are now const
   * generates version.h using AC_OUTPUT macro in ./configure
 
-2010-07-06 version 0.5.1:
+# 2010-07-06 version 0.5.1:
 
   * Add msgpack_vrefbuffer_new and msgpack_vrefbuffer_free
   * Add msgpack_sbuffer_new and msgpack_sbuffer_free
@@ -61,7 +402,7 @@
   * Add msgpack_version{,_major,_minor} functions to check library version
   * ./configure supports --disable-cxx option not to build C++ API
 
-2010-04-29 version 0.5.0:
+# 2010-04-29 version 0.5.0:
 
   * msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
   * New safe streaming deserializer API.
@@ -69,4 +410,3 @@
   * Add operator==(object, const T&)
   * MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
   * C++ programs doesn't need to link "msgpackc" library.
-

CMakeLists.txt

@@ -1,265 +0,0 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
-PROJECT (msgpack)
-
-FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
-STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
-SET (VERSION_MAJOR ${CMAKE_MATCH_1})
-STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
-SET (VERSION_MINOR ${CMAKE_MATCH_1})
-STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
-SET (VERSION_REVISION ${CMAKE_MATCH_1})
-SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
-
-SET (prefix ${CMAKE_INSTALL_PREFIX})
-SET (exec_prefix "\${prefix}")
-SET (libdir "\${exec_prefix}/lib")
-SET (includedir "\${prefix}/include")
-
-OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
-OPTION (MSGPACK_32BIT "32bit compile" OFF)
-
-IF (MSGPACK_CXX11)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-      MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11 yet.")
-   ENDIF ()
-ENDIF ()
-
-IF (MSGPACK_32BIT)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ENDIF ()
-ENDIF ()
-
-FIND_PACKAGE (GTest)
-FIND_PACKAGE (ZLIB)
-FIND_PACKAGE (Threads)
-IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND)
-    OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
-ENDIF ()
-
-OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
-
-INCLUDE (CheckCXXSourceCompiles)
-CHECK_CXX_SOURCE_COMPILES ("
-#include <bits/atomicity.h>
-int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
-int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
-int main(int argc, char * argv[])
-{
-    atomic_sub(1);
-    atomic_add(1);
-}
-" MSGPACK_ENABLE_GCC_CXX_ATOMIC)
-
-IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC)
-    LIST (APPEND msgpack_SOURCES
-        src/gcc_atomic.cpp
-    )
-ENDIF ()
-
-
-LIST (APPEND msgpack_SOURCES
-    src/unpack.c
-    src/objectc.c
-    src/version.c
-    src/vrefbuffer.c
-    src/zone.c
-)
-
-LIST (APPEND msgpack_HEADERS
-    include/msgpack/pack_define.h
-    include/msgpack/pack_template.h
-    include/msgpack/unpack_define.h
-    include/msgpack/unpack_template.h
-    include/msgpack/util.h
-    include/msgpack/sysdep.h
-    include/msgpack/gcc_atomic.h
-    include/msgpack/sbuffer.h
-    include/msgpack/version.h
-    include/msgpack/vrefbuffer.h
-    include/msgpack/zbuffer.h
-    include/msgpack/fbuffer.h
-    include/msgpack/pack.h
-    include/msgpack/unpack.h
-    include/msgpack/object.h
-    include/msgpack/zone.h
-)
-
-IF (MSGPACK_ENABLE_CXX)
-    LIST (APPEND msgpack_HEADERS
-        include/msgpack.hpp
-        include/msgpack_fwd.hpp
-        include/msgpack/adaptor/bool.hpp
-        include/msgpack/adaptor/bool_fwd.hpp
-        include/msgpack/adaptor/char_ptr.hpp
-        include/msgpack/adaptor/char_ptr_fwd.hpp
-        include/msgpack/adaptor/check_container_size.hpp
-        include/msgpack/adaptor/cpp11/array.hpp
-        include/msgpack/adaptor/cpp11/array_fwd.hpp
-        include/msgpack/adaptor/cpp11/array_char.hpp
-        include/msgpack/adaptor/cpp11/array_char_fwd.hpp
-        include/msgpack/adaptor/cpp11/forward_list.hpp
-        include/msgpack/adaptor/cpp11/forward_list_fwd.hpp
-        include/msgpack/adaptor/cpp11/tuple.hpp
-        include/msgpack/adaptor/cpp11/tuple_fwd.hpp
-        include/msgpack/adaptor/cpp11/unordered_map.hpp
-        include/msgpack/adaptor/cpp11/unordered_map_fwd.hpp
-        include/msgpack/adaptor/cpp11/unordered_set.hpp
-        include/msgpack/adaptor/cpp11/unordered_set_fwd.hpp
-        include/msgpack/adaptor/define.hpp
-        include/msgpack/adaptor/deque.hpp
-        include/msgpack/adaptor/deque_fwd.hpp
-        include/msgpack/adaptor/detail/cpp03_define.hpp
-        include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
-        include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp
-        include/msgpack/adaptor/detail/cpp11_define.hpp
-        include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
-        include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp
-        include/msgpack/adaptor/fixint.hpp
-        include/msgpack/adaptor/fixint_fwd.hpp
-        include/msgpack/adaptor/float.hpp
-        include/msgpack/adaptor/float_fwd.hpp
-        include/msgpack/adaptor/int.hpp
-        include/msgpack/adaptor/int_fwd.hpp
-        include/msgpack/adaptor/list.hpp
-        include/msgpack/adaptor/list_fwd.hpp
-        include/msgpack/adaptor/map.hpp
-        include/msgpack/adaptor/map_fwd.hpp
-        include/msgpack/adaptor/msgpack_tuple.hpp
-        include/msgpack/adaptor/msgpack_tuple_fwd.hpp
-        include/msgpack/adaptor/nil.hpp
-        include/msgpack/adaptor/nil_fwd.hpp
-        include/msgpack/adaptor/pair.hpp
-        include/msgpack/adaptor/pair_fwd.hpp
-        include/msgpack/adaptor/raw.hpp
-        include/msgpack/adaptor/raw_fwd.hpp
-        include/msgpack/adaptor/set.hpp
-        include/msgpack/adaptor/set_fwd.hpp
-        include/msgpack/adaptor/string.hpp
-        include/msgpack/adaptor/string_fwd.hpp
-        include/msgpack/adaptor/tr1/unordered_map.hpp
-        include/msgpack/adaptor/tr1/unordered_map_fwd.hpp
-        include/msgpack/adaptor/tr1/unordered_set.hpp
-        include/msgpack/adaptor/tr1/unordered_set_fwd.hpp
-        include/msgpack/adaptor/vector.hpp
-        include/msgpack/adaptor/vector_fwd.hpp
-        include/msgpack/adaptor/vector_bool.hpp
-        include/msgpack/adaptor/vector_bool_fwd.hpp
-        include/msgpack/adaptor/vector_char.hpp
-        include/msgpack/adaptor/vector_char_fwd.hpp
-        include/msgpack/cpp_config.hpp
-        include/msgpack/detail/cpp03_zone.hpp
-        include/msgpack/detail/cpp11_zone.hpp
-        include/msgpack/fbuffer.hpp
-        include/msgpack/object.hpp
-        include/msgpack/object_fwd.hpp
-        include/msgpack/pack.hpp
-        include/msgpack/sbuffer.hpp
-        include/msgpack/type.hpp
-        include/msgpack/unpack.hpp
-        include/msgpack/version.hpp
-        include/msgpack/versioning.hpp
-        include/msgpack/vrefbuffer.hpp
-        include/msgpack/zbuffer.hpp
-        include/msgpack/zone.hpp
-    )
-ENDIF ()
-
-EXECUTE_PROCESS (
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
-)
-
-CONFIGURE_FILE (
-    msgpack.pc.in
-    msgpack.pc
-    @ONLY
-)
-
-INCLUDE_DIRECTORIES (
-    ./
-    include/
-    ${CMAKE_CURRENT_BINARY_DIR}/include/
-)
-
-ADD_LIBRARY (msgpack SHARED
-    ${msgpack_SOURCES}
-    ${msgpack_HEADERS}
-)
-
-ADD_LIBRARY (msgpack-static STATIC
-    ${msgpack_SOURCES}
-    ${msgpack_HEADERS}
-)
-
-SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack")
-SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib")
-SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0)
-
-IF (MSGPACK_BUILD_TESTS)
-    ENABLE_TESTING ()
-    SET(CTEST_MEMORYCHECK_COMMAND "/usr/bin/valgrind")
-    INCLUDE(Dart)
-    SET(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1")
-    ADD_SUBDIRECTORY (test)
-ENDIF ()
-
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC")
-    SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" )
-ENDIF ()
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-        STRING(REGEX REPLACE "/W[0-4]" "/W3" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    ELSE ()
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
-    ENDIF ()
-ENDIF ()
-
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10")
-    SET_SOURCE_FILES_PROPERTIES(${msgpack_SOURCES} PROPERTIES LANGUAGE CXX)
-ENDIF()
-
-IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-    SET(CMAKE_INSTALL_LIBDIR lib)
-ENDIF ()
-
-INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
-INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
-INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-
-# Doxygen
-FIND_PACKAGE (Doxygen)
-IF (DOXYGEN_FOUND)
-    ADD_CUSTOM_TARGET (
-        doxygen_c
-        COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS      = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY   = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        VERBATIM
-    )
-    ADD_CUSTOM_TARGET (
-        doxygen_cpp
-        COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS      = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY   = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        VERBATIM
-    )
-    ADD_CUSTOM_TARGET (
-        doxygen
-        DEPENDS doxygen_c doxygen_cpp
-    )
-ENDIF ()

COPYING

@@ -1,14 +1,5 @@
-Copyright (C) 2008-2010 FURUHASHI Sadayuki
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+Copyright (C) 2008-2015 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)

CROSSLANG.md

@@ -1,38 +0,0 @@
-MessagePack cross-language test cases
-=====================================
-
-## cases
-
-Valid serialized data are stored in "cases.mpac" and "cases_compact.mpac".
-These files describe same objects. And "cases.json" describes an array of the described objects.
-
-Thus you can verify your implementations as comparing the objects.
-
-
-## crosslang
-
-The *crosslang* tool reads serialized data from stdin and writes re-serialize data to stdout.
-
-There are C++ and Ruby implementation of crosslang tool. You can verify your implementation
-as comparing that implementations.
-
-### C++ version
-
-    $ cd ../cpp && ./configure && make && make install
-    or
-    $ port install msgpack  # MacPorts
-    
-    $ g++ -Wall crosslang.cc -lmsgpack -o crosslang
-
-    $ ./crosslang
-    Usage: ./crosslang [in-file] [out-file]
-
-### Ruby version
-
-    $ gem install msgpack
-    or
-    $ port install rb_msgpack   # MacPorts
-
-    $ ruby crosslang.rb
-    Usage: crosslang.rb [in-file] [out-file]
-

LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

Makefile.am

@@ -1,21 +0,0 @@
-SUBDIRS = src test
-
-DOC_FILES = \
-		README.md \
-		LICENSE \
-		NOTICE \
-		msgpack_vc8.vcproj \
-		msgpack_vc8.sln \
-		msgpack_vc.postbuild.bat
-
-EXTRA_DIST = \
-		$(DOC_FILES) CMakeLists.txt test/CMakeLists.txt
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = msgpack.pc
-
-doxygen:
-	./preprocess clean
-	cd src && $(MAKE) doxygen
-	./preprocess
-

NOTICE

@@ -0,0 +1,14 @@
+This product bundles Boost Predef and Boost Preprocessor.
+They are 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)
+
+For details, see the following files:
+
+external/boost/predef
+include/msgpack/predef.h
+include/msgpack/predef/*
+
+external/boost/preprocessor
+include/msgpack/preprocessor.hpp
+include/msgpack/preprocessor/*

QUICKSTART-C.md

@@ -1,194 +0,0 @@
-# Implementation Status
-
-The serialization library is production-ready.
-
-Currently, no RPC implementation is not available.
-
-# Install
-
-
-## Mac OS X with MacPorts
-
-On Mac OS X, you can install MessagePack for C using MacPorts.
-
-```
-$ sudo port install msgpack
-```
-
-You might need to run `sudo port selfupdate` before installing to update the package repository.
-
-You can also install via Homebrew.
-
-```
-$ sudo brew install msgpack
-```
-
-## FreeBSD with Ports Collection
-
-On FreeBSD, you can use Ports Collection. Install [net/msgpack|http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/] package.
-
-## Gentoo Linux with Portage
-
-On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack|http://gentoo-portage.com/dev-libs/msgpack] package.
-
-## Other UNIX-like platform with ./configure
-
-On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`.
-
-```
-$ wget http://msgpack.org/releases/cpp/msgpack-0.5.5.tar.gz
-$ tar zxvf msgpack-0.5.5.tar.gz
-$ cd msgpack-0.5.5
-$ ./configure
-$ make
-$ sudo make install
-```
-
-## Windows
-
-On Windows, download source package from [here|https://sourceforge.net/projects/msgpack/files/] and extract it.
-Then open `msgpack_vc8.vcproj` file and build it using batch build. It builds libraries on `lib/` folder and header files on `include/` folder.
-
-You can build using command line as follows:
-
-```
-> vcbuild msgpack_vc2008.vcproj
-> dir lib       % DLL files are here
-> dir include   % header files are here
-```
-
-## Install from git repository
-
-You need to install gcc (4.1.0 or higher), autotools.
-
-```
-$ git clone git@github.com:msgpack/msgpack.git
-$ cd msgpack/cpp
-$ ./bootstrap
-$ ./configure
-$ make
-$ sudo make install
-```
-
-# Serialization QuickStart for C
-
-## First program
-
-Include `msgpack.h` header and link `msgpack` library to use MessagePack on your program.
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-
-        /* creates buffer and serializer instance. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-
-        /* serializes ["Hello", "MessagePack"]. */
-        msgpack_pack_array(pk, 2);
-        msgpack_pack_raw(pk, 5);
-        msgpack_pack_raw_body(pk, "Hello", 5);
-        msgpack_pack_raw(pk, 11);
-        msgpack_pack_raw_body(pk, "MessagePack", 11);
-
-        /* deserializes it. */
-        msgpack_unpacked msg;
-        msgpack_unpacked_init(&msg);
-        bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
-
-        /* prints the deserialized object. */
-        msgpack_object obj = msg.data;
-        msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
-
-        /* cleaning */
-        msgpack_sbuffer_free(buffer);
-        msgpack_packer_free(pk);
-}
-```
-
-## Simple program with a loop
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-
-        /* creates buffer and serializer instance. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-        
-        int j;
-
-        for(j = 0; j<23; j++) {
-           /* NB: the buffer needs to be cleared on each iteration */
-           msgpack_sbuffer_clear(buffer);
-
-           /* serializes ["Hello", "MessagePack"]. */
-           msgpack_pack_array(pk, 3);
-           msgpack_pack_raw(pk, 5);
-           msgpack_pack_raw_body(pk, "Hello", 5);
-           msgpack_pack_raw(pk, 11);
-           msgpack_pack_raw_body(pk, "MessagePack", 11);
-           msgpack_pack_int(pk, j);
-
-           /* deserializes it. */
-           msgpack_unpacked msg;
-           msgpack_unpacked_init(&msg);
-           bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
-
-           /* prints the deserialized object. */
-           msgpack_object obj = msg.data;
-           msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
-           puts("");
-        }
-
-        /* cleaning */
-        msgpack_sbuffer_free(buffer);
-        msgpack_packer_free(pk);
-}
-```
-
-## Streaming feature
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-        /* serializes multiple objects using msgpack_packer. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-        msgpack_pack_int(pk, 1);
-        msgpack_pack_int(pk, 2);
-        msgpack_pack_int(pk, 3);
-
-        /* deserializes these objects using msgpack_unpacker. */
-        msgpack_unpacker pac;
-        msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
-
-        /* feeds the buffer. */
-        msgpack_unpacker_reserve_buffer(&pac, buffer->size);
-        memcpy(msgpack_unpacker_buffer(&pac), buffer->data, buffer->size);
-        msgpack_unpacker_buffer_consumed(&pac, buffer->size);
-
-        /* now starts streaming deserialization. */
-        msgpack_unpacked result;
-        msgpack_unpacked_init(&result);
-
-        while(msgpack_unpacker_next(&pac, &result)) {
-            msgpack_object_print(stdout, result.data);
-            puts("");
-        }
-
-        /* results:
-         * $ gcc stream.cc -lmsgpack -o stream
-         * $ ./stream
-         * 1
-         * 2
-         * 3
-         */
-}
-```

QUICKSTART-CPP.md

@@ -1,159 +0,0 @@
-# Implementation Status
-
-The serialization library is production-ready.
-
-Currently, RPC implementation is 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::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        // print the deserialized object.
-        msgpack::object obj = msg.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++ hello.cc -lmsgpack -o hello
-$ ./hello
-["Hello", "MessagePack"]
-```
-
-## Streaming feature
-
-```cpp
-#include <msgpack.hpp>
-#include <iostream>
-#include <string>
-
-int main(void) {
-        // 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::unpacked result;
-        while(pac.next(&result)) {
-            std::cout << result.get() << std::endl;
-        }
-
-        // results:
-        // $ g++ stream.cc -lmsgpack -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(void) {
-        // 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(void) {
-        std::vector<myclass> vec;
-        // add some elements into vec...
-
-        // you can serialize myclass directly
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, vec);
-
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        msgpack::object obj = msg.get();
-
-        // you can convert object to myclass directly
-        std::vector<myclass> rvec;
-        obj.convert(&rvec);
-}
-```

README.md

@@ -1,9 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 1.0.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c)
-
-It's like JSON but small and fast.
+It's like JSON but smaller and faster.
 
 Overview
 --------
@@ -11,197 +9,21 @@ Overview
 [MessagePack](http://msgpack.org/) is an efficient binary serialization
 format, which lets you exchange data among multiple languages like JSON,
 except that it's faster and smaller. Small integers are encoded into a
-single byte while typical short strings require only one extra byte in
+single byte and short strings require only one extra byte in
 addition to the strings themselves.
 
-Example
--------
+### C Library
 
-In C:
+See [c_master](https://github.com/msgpack/msgpack-c/tree/c_master)
 
-```c
-#include <msgpack.h>
-#include <stdio.h>
+### C++ Library
 
-int main(void)
-{
-    /* msgpack::sbuffer is a simple buffer implementation. */
-    msgpack_sbuffer sbuf;
-    msgpack_sbuffer_init(&sbuf);
-
-    /* serialize values into the buffer using msgpack_sbuffer_write callback function. */
-    msgpack_packer pk;
-    msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(&pk, 3);
-    msgpack_pack_int(&pk, 1);
-    msgpack_pack_true(&pk);
-    msgpack_pack_str(&pk, 7);
-    msgpack_pack_str_body(&pk, "example", 7);
-
-    /* deserialize the buffer into msgpack_object instance. */
-    /* deserialized object is valid during the msgpack_zone instance alive. */
-    msgpack_zone mempool;
-    msgpack_zone_init(&mempool, 2048);
-
-    msgpack_object deserialized;
-    msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
-
-    /* print the deserialized object. */
-    msgpack_object_print(stdout, deserialized);
-    puts("");
-
-    msgpack_zone_destroy(&mempool);
-    msgpack_sbuffer_destroy(&sbuf);
-
-    return 0;
-}
-```
-
-See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details.
-
-In C++:
-
-```c++
-#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::unpacked result;
-
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.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;
-}
-```
-
-See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
-
-Usage
------
-
-### C++ Header Only Library
-
-When you use msgpack on C++03 and C++11, you can just add
-msgpack-c/include to your include path:
-
-    g++ -I msgpack-c/include your_source_file.cpp
-
-If you want to use C version of msgpack, you need to build it. You can
-also install the C and C++ versions of msgpack.
-
-### Building and Installing
-
-#### Install from git repository
-
-##### Using autotools
-
-You will need:
-
- - `gcc >= 4.1.0` or `clang >= 3.3.0`
- - `autoconf >= 2.60`
- - `automake >= 1.10`
- - `libtool >= 2.2.4`
-
-The build steps below are for C and C++03. If compiling for C++11,
-add `-std=c++11` to the environmental variable `CXXFLAGS` with
-`export CXXFLAGS="$CXXFLAGS -std=c++11"` prior to following the
-directions below.
-
-```bash
-$ git clone https://github.com/msgpack/msgpack-c
-$ cd msgpack-c
-$ ./bootstrap
-$ ./configure
-$ make
-```
-
-You can install the resulting library like this:
-
-```bash
-$ sudo make install
-```
-##### Using cmake
-
-###### Using the Terminal (CLI)
-
-You will need:
-
- - `gcc >= 4.1.0`
- - `cmake >= 2.8.0`
-
-C and C++03:
-
-    $ git clone https://github.com/msgpack/msgpack-c.git
-    $ cd msgpack-c
-    $ cmake .
-    $ make
-    $ sudo make install
-
-If you want to setup C++11 version of msgpack instead,
-execute the following commands:
-
-    $ git clone https://github.com/msgpack/msgpack-c.git
-    $ cd msgpack-c
-    $ cmake -DMSGPACK_CXX11=ON .
-    $ sudo make install
-
-##### GUI on Windows
-
-Clone msgpack-c git repository.
-
-    $ git clone https://github.com/msgpack/msgpack-c.git
-
-or using GUI git client.
-
-e.g.) tortoise git https://code.google.com/p/tortoisegit/
-
-1. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
-
-2. Set 'Where is the source code:' text box and 'Where to build
-the binaries:' text box.
-
-3. Click 'Configure' button.
-
-4. Choose your Visual Studio version.
-
-5. Click 'Generate' button.
-
-6. Open the created msgpack.sln on Visual Studio.
-
-7. Build all.
+See [cpp_master](https://github.com/msgpack/msgpack-c/tree/cpp_master)
 
 ### Documentation
 
-You can get addtional information on the
-[wiki](https://github.com/msgpack/msgpack-c/wiki/cpp_overview).
+You can get additional information including the tutorial on the
+[wiki](https://github.com/msgpack/msgpack-c/wiki).
 
 Contributing
 ------------
@@ -215,5 +37,5 @@ Here's the list of [great contributors](https://github.com/msgpack/msgpack-c/gra
 License
 -------
 
-`msgpack-c` is licensed under the Apache License Version 2.0. See
-the [`LICENSE`](./LICENSE) file for details.
+`msgpack-c` is licensed under the Boost Software License, Version 1.0. See
+the [`LICENSE_1_0.txt`](./LICENSE_1_0.txt) file for details.

bootstrap

@@ -1,121 +0,0 @@
-#!/bin/sh
-# vim:ts=4:sw=4
-# Calls autotools to build configure script and Makefile.in.
-# Generated automatically using bootstrapper 0.2.1
-# http://bootstrapper.sourceforge.net/
-#
-# Copyright (C) 2002 Anthony Ventimiglia
-#
-# This bootstrap script is free software; you can redistribute 
-# it and/or modify it under the terms of the GNU General Public 
-# License as published by the Free Software Foundation; either 
-# version 2 of the License, or (at your option) any later version.
-#
-#
-# Calls proper programs to create configure script and Makefile.in files.
-# if run with the --clean option, bootstrap removes files it generates. To
-# clean all autogenerated files (eg: for cvs imports) first run 
-# make distclean, then bootstrap --clean
-# see bootstrapper(1) for more infor
-
-
-if test x"$1" = x"--help"; then
-	echo "$0: automatic bootstrapping utility for GNU Autotools"
-	echo "		cleans up old autogenerated files and runs autoconf,"
-	echo "		automake and aclocal on local directory"
-	echo 
-	echo "		--clean		clean up auto-generated files without"
-	echo "					creating new scripts"
-	echo 
-	exit 0
-fi
-
-
-mkdir -p ac
-test -f AUTHORS   || touch AUTHORS
-test -f COPYING   || touch COPYING
-test -f ChangeLog || touch ChangeLog
-test -f NEWS      || touch NEWS
-test -f NOTICE    || touch NOTICE
-test -f README    || cp -f README.md README
-
-ACLOCAL="aclocal"
-ACLOCAL_FILES="aclocal.m4"
-ALWAYS_CLEAN="config.status config.log config.cache libtool"
-AUTOCONF="autoconf"
-AUTOCONF_FILES="configure"
-AUTOHEADER="autoheader"
-AUTOHEADER_FILES=""
-AUTOMAKE="automake --add-missing --copy"
-AUTOMAKE_FILES="config.sub stamp-h.in ltmain.sh missing mkinstalldirs install-sh config.guess"
-CONFIG_AUX_DIR="."
-CONFIG_FILES="stamp-h ltconfig"
-CONFIG_HEADER=""
-if [ x`uname` = x"Darwin" ]; then
-	LIBTOOLIZE="glibtoolize --force --copy"
-else
-	LIBTOOLIZE="libtoolize --force --copy"
-fi
-LIBTOOLIZE_FILES="config.sub ltmain.sh config.guess"
-RM="rm"
-SUBDIRS="[]"
-
-
-# These are files created by configure, so we'll always clean them
-for i in $ALWAYS_CLEAN; do
-	test -f $i && \
-	$RM $i
-done
-
-if test x"$1" = x"--clean"; then
-	#
-	#Clean Files left by previous bootstrap run
-	#
-	if test -n "$CONFIG_AUX_DIR"; 
-		then CONFIG_AUX_DIR="$CONFIG_AUX_DIR/"
-	fi
-	# Clean Libtoolize generated files
-	for cf in $LIBTOOLIZE_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-	#aclocal.m4 created by aclocal
-	test -f $ACLOCAL_FILES && $RM $ACLOCAL_FILES
-	#Clean Autoheader Generated files
-	for cf in $AUTOHEADER_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	# remove config header (Usaually config.h)
-	test -n "$CONFIG_HEADER" && test -f $CONFIG_HEADER && $RM $CONFIG_HEADER
-	#Clean Automake generated files
-	for cf in $AUTOMAKE_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	for i in $SUBDIRS; do
-		test -f $i/Makefile.in && \
-		$RM $i/Makefile.in
-	done
-	#Autoconf generated files
-	for cf in $AUTOCONF_FILES; do
-		test -f $cf && \
-		$RM $cf
-	done
-	for cf in $CONFIG_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-else
-	$LIBTOOLIZE
-	$ACLOCAL
-	$AUTOHEADER
-	$AUTOMAKE
-	$AUTOCONF
-fi
-
-

cases.json

@@ -1 +0,0 @@
-[false,true,null,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,127,127,255,65535,4294967295,-32,-32,-128,-32768,-2147483648,0.0,-0.0,1.0,-1.0,"a","a","a","","","",[0],[0],[0],[],[],[],{},{},{},{"a":97},{"a":97},{"a":97},[[]],[["a"]]]

cases_gen.rb

@@ -1,99 +0,0 @@
-#
-# MessagePack format test case
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-require 'json'
-
-source = <<EOF
-c2                          # false
-c3                          # true
-c0                          # nil
-00                          # 0 Positive FixNum
-cc 00                       # 0 uint8
-cd 00 00                    # 0 uint16
-ce 00 00 00 00              # 0 uint32
-cf 00 00 00 00 00 00 00 00  # 0 uint64
-d0 00                       # 0 int8
-d1 00 00                    # 0 int16
-d2 00 00 00 00              # 0 int32
-d3 00 00 00 00 00 00 00 00  # 0 int64
-ff                          # -1 Negative FixNum
-d0 ff                       # -1 int8
-d1 ff ff                    # -1 int16
-d2 ff ff ff ff              # -1 int32
-d3 ff ff ff ff ff ff ff ff  # -1 int64
-7f                          # 127 Positive FixNum
-cc 7f                       # 127 uint8
-cd 00 ff                    # 255 uint16
-ce 00 00 ff ff              # 65535 uint32
-cf 00 00 00 00 ff ff ff ff  # 4294967295 uint64
-e0                          # -32 Negative FixNum
-d0 e0                       # -32 int8
-d1 ff 80                    # -128 int16
-d2 ff ff 80 00              # -32768 int32
-d3 ff ff ff ff 80 00 00 00  # -2147483648 int64
-#ca 00 00 00 00              # 0.0 float
-cb 00 00 00 00 00 00 00 00  # 0.0 double
-#ca 80 00 00 00              # -0.0 float
-cb 80 00 00 00 00 00 00 00  # -0.0 double
-cb 3f f0 00 00 00 00 00 00  # 1.0 double
-cb bf f0 00 00 00 00 00 00  # -1.0 double
-a1 61                       # "a" FixRaw
-da 00 01 61                 # "a" raw 16
-db 00 00 00 01 61           # "a" raw 32
-a0                          # "" FixRaw
-da 00 00                    # "" raw 16
-db 00 00 00 00              # "" raw 32
-91 00                       # [0] FixArray
-dc 00 01 00                 # [0] array 16
-dd 00 00 00 01 00           # [0] array 32
-90                          # [] FixArray
-dc 00 00                    # [] array 16
-dd 00 00 00 00              # [] array 32
-80                          # {} FixMap
-de 00 00                    # {} map 16
-df 00 00 00 00              # {} map 32
-81 a1 61 61                 # {"a"=>97} FixMap
-de 00 01 a1 61 61           # {"a"=>97} map 16
-df 00 00 00 01 a1 61 61     # {"a"=>97} map 32
-91 90                       # [[]]
-91 91 a1 61                 # [["a"]]
-EOF
-
-source.gsub!(/\#.+$/,'')
-bytes = source.strip.split(/\s+/).map {|x| x.to_i(16) }.pack('C*')
-
-objs = []
-compact_bytes = ""
-
-pac = MessagePack::Unpacker.new
-pac.feed(bytes)
-pac.each {|obj|
-	p obj
-	objs << obj
-	compact_bytes << obj.to_msgpack
-}
-
-json = objs.to_json
-
-# self check
-cpac = MessagePack::Unpacker.new
-cpac.feed(compact_bytes)
-cpac.each {|cobj|
-	obj = objs.shift
-	if obj != cobj
-		puts "** SELF CHECK FAILED **"
-		puts "expected: #{obj.inspect}"
-		puts "actual: #{cobj.inspect}"
-		exit 1
-	end
-}
-
-File.open("cases.mpac","w") {|f| f.write(bytes) }
-File.open("cases_compact.mpac","w") {|f| f.write(compact_bytes) }
-File.open("cases.json","w") {|f| f.write(json) }
-

ci/build_autotools.sh

@@ -1,57 +0,0 @@
-#!/bin/sh
-
-./bootstrap
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ $1 = "cpp11" ]
-then
-    if [ $2 = "32" ]
-    then
-        ./configure CFLAGS="-m32" CXXFLAGS="-std=c++11 -m32"
-    else
-        ./configure CXXFLAGS="-std=c++11"
-    fi
-else
-    if [ $2 = "32" ]
-    then
-        ./configure CFLAGS="-m32" CXXFLAGS="-m32"
-    else
-        ./configure
-    fi
-fi
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make check
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make install DESTDIR=`pwd`/install
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-exit 0

ci/build_cmake.sh

@@ -1,83 +0,0 @@
-#!/bin/bash
-
-mkdir build
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-cd build
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ $1 = "cpp11" ]
-then
-    if [ $2 = "32" ]
-    then
-        cmake -DMSGPACK_CXX11=ON -DMSGPACK_32BIT=ON ..
-    else
-        cmake -DMSGPACK_CXX11=ON ..
-    fi
-else
-    if [ $2 = "32" ]
-    then
-        cmake -DMSGPACK_32BIT=ON ..
-    else
-        cmake ..
-    fi
-fi
-
-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
-
-make install DESTDIR=`pwd`/install
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ $2 != "32" ]
-then
-    ctest -T memcheck | tee memcheck.log
-
-    ret=${PIPESTATUS[0]}
-    if [ $ret -ne 0 ]
-    then
-        exit $ret
-    fi
-    cat memcheck.log | grep "Memory Leak" > /dev/null
-    ret=$?
-    if [ $ret -eq 0 ]
-    then
-        exit 1
-    fi
-fi
-
-exit 0

configure.in

@@ -1,98 +0,0 @@
-AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION[[:space:]]*\([[:alnum:]]*\)/\1/g' | tr -d "\n"]))
-AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE
-AC_CONFIG_HEADER(config.h)
-AC_SUBST(CFLAGS)
-CFLAGS="-O3 -Wall $CFLAGS"
-
-AC_SUBST(CXXFLAGS)
-CXXFLAGS="-O3 -Wall $CXXFLAGS"
-
-
-AC_PROG_CC
-
-
-AC_MSG_CHECKING([if C++ API is enabled])
-AC_ARG_ENABLE(cxx,
-	AS_HELP_STRING([--disable-cxx],
-				   [don't build C++ API]) )   #'
-AC_MSG_RESULT([$enable_cxx])
-if test "$enable_cxx" != "no"; then
-	AC_PROG_CXX
-	AM_PROG_CC_C_O
-fi
-AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
-
-
-AC_PROG_LIBTOOL
-AM_PROG_AS
-
-
-AC_MSG_CHECKING([if debug option is enabled])
-AC_ARG_ENABLE(debug,
-	AS_HELP_STRING([--disable-debug],
-				   [disable assert macros and omit -g option]) )
-AC_MSG_RESULT([$enable_debug])
-if test "$enable_debug" != "no"; then
-	CXXFLAGS="$CXXFLAGS -g"
-	CFLAGS="$CFLAGS -g"
-else
-	CXXFLAGS="$CXXFLAGS -DNDEBUG"
-	CFLAGS="$CFLAGS -DNDEBUG"
-fi
-
-
-AC_CACHE_CHECK([for __sync_* atomic operations], msgpack_cv_atomic_ops, [
-	AC_TRY_LINK([
-		int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
-		int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
-	], [atomic_sub(1); atomic_add(1);], msgpack_cv_atomic_ops="yes")
-	])
-if test "$msgpack_cv_atomic_ops" != "yes"; then
-	if test "$enable_cxx" = "no"; then
-		AC_MSG_ERROR([__sync_* atomic operations are not found. Try to enable C++ support.
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-					  ])
-	fi
-
-	AC_LANG_PUSH([C++])
-	AC_CACHE_CHECK([for __gnu_cxx::__exchange_and_add], msgpack_cv_gcc_cxx_atomic_ops, [
-		AC_TRY_LINK([
-			#include <bits/atomicity.h>
-			int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
-			int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
-		], [atomic_sub(1); atomic_add(1);], msgpack_cv_gcc_cxx_atomic_ops="yes")
-		])
-	AC_LANG_POP([C++])
-
-	if test "$msgpack_cv_gcc_cxx_atomic_ops" != "yes"; then
-		AC_MSG_ERROR([__sync_* atomic operations nor __gnu_cxx::__exchange_and_add are not found.
-
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-])
-
-	else
-		enable_gcc_cxx_atomic=yes
-	fi
-fi
-
-AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes")
-
-major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\1/'`
-minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\2/'`
-revision=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'`
-AC_SUBST(VERSION_MAJOR, $major)
-AC_SUBST(VERSION_MINOR, $minor)
-AC_SUBST(VERSION_REVISION, $revision)
-
-
-AC_OUTPUT([Makefile
-		   msgpack.pc
-		   src/Makefile
-		   test/Makefile])

crosslang.cc

@@ -1,133 +0,0 @@
-//
-// MessagePack cross-language test tool
-//
-// $ cd ../cpp && ./configure && make && make install
-// or
-// $ port install msgpack  # MacPorts
-//
-// $ g++ -Wall crosslang.cc -lmsgpack
-//
-#include <msgpack.hpp>
-#include <iostream>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-
-static int run(int infd, int outfd)
-try {
-	msgpack::unpacker pac;
-
-	while(true) {
-		pac.reserve_buffer(32*1024);
-
-		ssize_t count =
-			read(infd, pac.buffer(), pac.buffer_capacity());
-
-		if(count <= 0) {
-			if(count == 0) {
-				return 0;
-			}
-			if(errno == EAGAIN || errno == EINTR) {
-				continue;
-			}
-			return 1;
-		}
-
-		pac.buffer_consumed(count);
-
-		msgpack::unpacked result;
-		while(pac.next(&result)) {
-			msgpack::sbuffer sbuf;
-			msgpack::pack(sbuf, result.get());
-
-			const char* p = sbuf.data();
-			const char* const pend = p + sbuf.size();
-			while(p < pend) {
-				ssize_t bytes = write(outfd, p, pend-p);
-
-				if(bytes <= 0) {
-					if(count == 0) {
-						return 0;
-					}
-					if(errno == EAGAIN || errno == EINTR) {
-						continue;
-					}
-					return 1;
-				}
-
-				p += bytes;
-			}
-
-		}
-	}
-
-	return 0;
-
-} catch (std::exception& e) {
-	std::cerr << e.what() << std::endl;
-	return 1;
-}
-
-static void usage(const char* prog)
-{
-	printf(
-		"Usage: %s [in-file] [out-file]\n"
-		"\n"
-		"This tool is for testing of MessagePack implementation.\n"
-		"This does following behavior:\n"
-		"\n"
-		"  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)\n"
-		"  2. Re-serializes the objects using C++ implementation of MessagePack (Note that C++ implementation is considered valid)\n"
-		"  3. Writes the re-serialized objects into <out-file> (default: stdout)\n"
-		"\n"
-		, prog);
-	exit(1);
-}
-
-int main(int argc, char* argv[])
-{
-	int infd = 0;
-	int outfd = 1;
-
-	if(argc < 1 || argc > 3) {
-		usage(argv[0]);
-	}
-
-	for(int i=1; i < argc; ++i) {
-		if(strlen(argv[i]) > 1 && argv[i][0] == '-') {
-			usage(argv[0]);
-		}
-	}
-
-	if(argc >= 2) {
-		const char* fname = argv[1];
-		if(strcmp(fname, "-") != 0) {
-			infd = open(fname, O_RDONLY);
-			if(infd < 0) {
-				perror("can't open input file");
-				exit(1);
-			}
-		}
-	}
-
-	if(argc >= 3) {
-		const char* fname = argv[2];
-		if(strcmp(fname, "-") != 0) {
-			outfd = open(fname, O_WRONLY | O_CREAT| O_TRUNC, 0666);
-			if(outfd < 0) {
-				perror("can't open output file");
-				exit(1);
-			}
-		}
-	}
-
-	int code = run(infd, outfd);
-
-	close(infd);
-	close(outfd);
-
-	return code;
-}
-

crosslang.rb

@@ -1,88 +0,0 @@
-#
-# MessagePack cross-language test tool
-#
-# $ gem install msgpack
-# or
-# $ port install rb_msgpack   # MacPorts
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-
-def run(inio, outio)
-	pac = MessagePack::Unpacker.new(inio)
-
-	begin
-		pac.each {|obj|
-			outio.write MessagePack.pack(obj)
-			outio.flush
-		}
-	rescue EOFError
-		return 0
-	rescue
-		$stderr.puts $!
-		return 1
-	end
-
-	return 0
-end
-
-def usage
-	puts <<EOF
-Usage: #{$0} [in-file] [out-file]
-
-This tool is for testing of MessagePack implementation.
-This does following behavior:
-
-  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)
-  2. Re-serializes the objects using Ruby implementation of MessagePack (Note that Ruby implementation is considered valid)
-  3. Writes the re-serialized objects into <out-file> (default: stdout)
-
-EOF
-	exit 1
-end
-
-inio = $stdin
-outio = $stdout
-
-if ARGV.length > 2
-	usage
-end
-
-ARGV.each {|str|
-	if str.size > 1 && str[0] == ?-
-		usage
-	end
-}
-
-if fname = ARGV[0]
-	unless fname == "-"
-		begin
-			inio = File.open(fname)
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-if fname = ARGV[1]
-	unless fname == "-"
-		begin
-			outio = File.open(fname, "w")
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-code = run(inio, outio)
-
-inio.close
-outio.close
-
-exit code
-

erb/cpp03_define.hpp.erb

@@ -1,158 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP03_DEFINE_HPP
-#define MSGPACK_CPP03_DEFINE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/msgpack_tuple_fwd.hpp"
-#include "msgpack/adaptor/int_fwd.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#define MSGPACK_DEFINE(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum) \
-  namespace msgpack { \
-  MSGPACK_API_VERSION_NAMESPACE(v1) { \
-    inline msgpack::object const& operator>> (msgpack::object const& o, enum& v) \
-    { \
-      int tmp; \
-      o >> tmp; \
-      v = static_cast<enum>(tmp); \
-      return o; \
-    } \
-    inline void operator<< (msgpack::object& o, const enum& v) \
-    { \
-      o << static_cast<int>(v); \
-    } \
-    inline void operator<< (msgpack::object::with_zone& o, const enum& v) \
-    { \
-      o << static_cast<int>(v); \
-    } \
-    namespace detail { \
-      template <typename Stream> \
-      struct packer_serializer<Stream, enum> { \
-        static msgpack::packer<Stream>& pack(msgpack::packer<Stream>& o, const enum& v) { \
-          return o << static_cast<int>(v); \
-        } \
-      }; \
-    } \
-  } \
-  }
-
-namespace msgpack {
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-namespace type {
-
-
-<% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define;
-
-
-template <>
-struct define<> {
-    typedef define<> 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 type_error(); }
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone&) const
-    {
-        o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = nullptr;
-        o->via.array.size = 0;
-    }
-};
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-    typedef define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
-    typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
-    define(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 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%>);<%}%>
-            }
-        }
-    }
-    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%>));
-        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%>;<%}%>
-};
-<%}%>
-
-inline define<> make_define()
-{
-    return define<>();
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
-{
-    return define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-
-}  // namespace type
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-}  // namespace msgpack
-
-
-#endif // MSGPACK_CPP03_DEFINE_HPP

erb/cpp03_msgpack_tuple.hpp.erb

@@ -1,216 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP
-#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-// FIXME operator==
-// FIXME operator!=
-<% GENERATION_LIMIT = 31 %>
-
-template <typename A0<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%><%}%>>
-struct tuple;
-
-template <typename Tuple, int N>
-struct tuple_element;
-
-template <typename Tuple, int N>
-struct const_tuple_element;
-
-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;
-};
-
-<%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;
-};
-<%}%>
-<%}%>
-
-template <>
-struct tuple<> {
-    tuple() {}
-    tuple(msgpack::object const& o) { o.convert(*this); }
-    typedef tuple<> value_type;
-};
-<%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;
-    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>(); }
-<%}%>
-
-inline tuple<> make_tuple()
-{
-    return tuple<>();
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
-{
-    return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-
-}  // namespace type
-
-inline msgpack::object const& operator>> (
-        msgpack::object const& o,
-        type::tuple<>&) {
-    if(o.type != msgpack::type::ARRAY) { throw type_error(); }
-    return o;
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline msgpack::object const& operator>> (
-        msgpack::object const& o,
-        type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-    if(o.type != msgpack::type::ARRAY) { throw type_error(); }
-    if(o.via.array.size < <%=i+1%>) { throw type_error(); }
-    <%0.upto(i) {|j|%>
-    o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
-    return o;
-}
-<%}%>
-
-template <typename Stream>
-inline const msgpack::packer<Stream>& operator<< (
-        msgpack::packer<Stream>& o,
-        const type::tuple<>&) {
-    o.pack_array(0);
-    return o;
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename Stream, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline const msgpack::packer<Stream>& operator<< (
-        msgpack::packer<Stream>& o,
-        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-    o.pack_array(<%=i+1%>);
-    <%0.upto(i) {|j|%>
-    o.pack(v.template get<<%=j%>>());<%}%>
-    return o;
-}
-<%}%>
-
-inline void operator<< (
-        msgpack::object::with_zone& o,
-        const type::tuple<>&) {
-    o.type = msgpack::type::ARRAY;
-    o.via.array.ptr = nullptr;
-    o.via.array.size = 0;
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline void operator<< (
-        msgpack::object::with_zone& o,
-        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-    o.type = msgpack::type::ARRAY;
-    o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
-    o.via.array.size = <%=i+1%>;
-    <%0.upto(i) {|j|%>
-    o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>
-}
-<%}%>
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-
-//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) {
-//  return o << "[]";
-//}
-//<%0.upto(GENERATION_LIMIT) {|i|%>
-//template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-//inline std::ostream& operator<< (std::ostream& o,
-//      const msgpack::type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-//  return o << "["
-//  <%0.upto(i) {|j|%>
-//  <<<%if j != 0 then%> ", " <<<%end%> v.template get<<%=j%>>()<%}%>
-//  << "]";
-//}
-//<%}%>
-
-#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP

erb/cpp03_msgpack_tuple_fwd.hpp.erb

@@ -1,125 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP
-#define MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-// FIXME operator==
-// FIXME operator!=
-<% GENERATION_LIMIT = 31 %>
-
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct tuple;
-
-template <typename Tuple, int N>
-struct tuple_element;
-
-template <typename Tuple, int N>
-struct const_tuple_element;
-
-template <typename T>
-struct tuple_type;
-
-<%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%>>;
-<%}%>
-<%}%>
-
-<%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%>>;
-<%}%>
-<%}%>
-
-template <>
-struct tuple<>;
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>;
-
-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);
-<%}%>
-
-tuple<> make_tuple();
-<%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(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>);
-<%}%>
-
-}  // namespace type
-
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    type::tuple<>&);
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v);
-<%}%>
-
-template <typename Stream>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const type::tuple<>&);
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename Stream, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v);
-<%}%>
-
-void operator<< (
-    msgpack::object::with_zone& o,
-    const type::tuple<>&);
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-void operator<< (
-    msgpack::object::with_zone& o,
-    const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v);
-<%}%>
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-
-//std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v);
-//<%0.upto(GENERATION_LIMIT) {|i|%>
-//template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-//std::ostream& operator<< (std::ostream& o,
-//      const msgpack::type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v);
-//<%}%>
-
-#endif // MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP

erb/cpp03_zone.hpp.erb

@@ -1,332 +0,0 @@
-//
-// MessagePack for C++ memory pool
-//
-// Copyright (C) 2008-2010 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP03_ZONE_HPP
-#define MSGPACK_CPP03_ZONE_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
-
-<% GENERATION_LIMIT = 15 %>
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-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(nullptr), m_end(nullptr), m_array(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 = 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 = 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 {
-                    break;
-                }
-            }
-            m_head->m_next = 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);
-    }
-    <%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(', ')%>);
-    <%}%>
-
-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);
-
-    void* 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 void* zone::allocate_align(size_t size, size_t align)
-{
-    char* aligned =
-        reinterpret_cast<char*>(
-            reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
-    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
-        m_chunk_list.m_free -= adjusted_size;
-        m_chunk_list.m_ptr  += adjusted_size;
-        return aligned;
-    }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
-}
-
-inline void* zone::allocate_no_align(size_t size)
-{
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
-    char* ptr = m_chunk_list.m_ptr;
-    m_chunk_list.m_free -= size;
-    m_chunk_list.m_ptr  += size;
-
-    return ptr;
-}
-
-inline void* 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 - size;
-    cl->m_ptr  = ptr + size;
-
-    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;
-}
-
-<%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));
-    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;
-    }
-}
-<%}%>
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP03_ZONE_HPP

example/c/lib_buffer_unpack.c

@@ -1,119 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-#include <assert.h>
-
-
-typedef struct receiver {
-    msgpack_sbuffer sbuf;
-    size_t rest;
-} receiver;
-
-receiver r;
-
-void receiver_init(receiver *r) {
-    msgpack_packer pk;
-
-    msgpack_sbuffer_init(&r->sbuf);
-    msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write);
-    /* 1st object */
-    msgpack_pack_array(&pk, 3);
-    msgpack_pack_int(&pk, 1);
-    msgpack_pack_true(&pk);
-    msgpack_pack_str(&pk, 7);
-    msgpack_pack_str_body(&pk, "example", 7);
-    /* 2nd object */
-    msgpack_pack_str(&pk, 6);
-    msgpack_pack_str_body(&pk, "second", 6);
-    /* 3rd object */
-    msgpack_pack_array(&pk, 2);
-    msgpack_pack_int(&pk, 42);
-    msgpack_pack_false(&pk);
-    r->rest = r->sbuf.size;
-}
-
-size_t receiver_recv(receiver *r, char* buf, size_t try_size) {
-    size_t off = r->sbuf.size - r->rest;
-
-    size_t actual_size = try_size;
-    if (actual_size > r->rest) actual_size = r->rest;
-
-    memcpy(buf, r->sbuf.data + off, actual_size);
-    r->rest -= actual_size;
-
-    return actual_size;
-}
-
-#define EACH_RECV_SIZE 4
-
-void unpack(receiver* r) {
-    /* buf is allocated by unpacker. */
-    msgpack_unpacker* unp = msgpack_unpacker_new(100);
-    msgpack_unpacked result;
-    msgpack_unpack_return ret;
-    char* buf;
-    size_t recv_len;
-
-    msgpack_unpacked_init(&result);
-    if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) {
-        bool expanded = msgpack_unpacker_reserve_buffer(unp, 100);
-        assert(expanded);
-    }
-    buf = msgpack_unpacker_buffer(unp);
-
-    recv_len = receiver_recv(r, buf, EACH_RECV_SIZE);
-    msgpack_unpacker_buffer_consumed(unp, recv_len);
-
-
-    int recv_count = 0;
-    while (recv_len > 0) {
-        int i = 0;
-        printf("receive count: %d %zd bytes received.:\n", recv_count++, recv_len);
-        ret = msgpack_unpacker_next(unp, &result);
-        while (ret == MSGPACK_UNPACK_SUCCESS) {
-            msgpack_object obj = result.data;
-
-            /* Use obj. */
-            printf("Object no %d:\n", i++);
-            msgpack_object_print(stdout, obj);
-            printf("\n");
-            /* If you want to allocate something on the zone, you can use zone. */
-            /* msgpack_zone* zone = result.zone; */
-            /* The lifetime of the obj and the zone,  */
-
-            ret = msgpack_unpacker_next(unp, &result);
-        }
-        if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
-            printf("The data in the buf is invalid format.\n");
-            msgpack_unpacked_destroy(&result);
-            return;
-        }
-        if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) {
-            bool expanded = msgpack_unpacker_reserve_buffer(unp, 100);
-            assert(expanded);
-        }
-        buf = msgpack_unpacker_buffer(unp);
-        recv_len = receiver_recv(r, buf, 4);
-        msgpack_unpacker_buffer_consumed(unp, recv_len);
-    }
-    msgpack_unpacked_destroy(&result);
-}
-
-int main(void) {
-    receiver r;
-    receiver_init(&r);
-
-    unpack(&r);
-
-    return 0;
-}
-
-/* Output */
-
-/*
-Object no 1:
-[1, true, "example"]
-Object no 2:
-"second"
-Object no 3:
-[42, false]
-*/

example/c/simple.c

@@ -1,37 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void)
-{
-    /* msgpack::sbuffer is a simple buffer implementation. */
-    msgpack_sbuffer sbuf;
-    msgpack_sbuffer_init(&sbuf);
-
-    /* serialize values into the buffer using msgpack_sbuffer_write callback function. */
-    msgpack_packer pk;
-    msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(&pk, 3);
-    msgpack_pack_int(&pk, 1);
-    msgpack_pack_true(&pk);
-    msgpack_pack_str(&pk, 7);
-    msgpack_pack_str_body(&pk, "example", 7);
-
-    /* deserialize the buffer into msgpack_object instance. */
-    /* deserialized object is valid during the msgpack_zone instance alive. */
-    msgpack_zone mempool;
-    msgpack_zone_init(&mempool, 2048);
-
-    msgpack_object deserialized;
-    msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
-
-    /* print the deserialized object. */
-    msgpack_object_print(stdout, deserialized);
-    puts("");
-
-    msgpack_zone_destroy(&mempool);
-    msgpack_sbuffer_destroy(&sbuf);
-
-    return 0;
-}
-

example/c/speed_test_uint32_array.c

@@ -1,36 +0,0 @@
-#include <msgpack.h>
-#include <assert.h>
-
-void test()
-{
-    size_t size = 10000000;
-    msgpack_sbuffer buf;
-    msgpack_sbuffer_init(&buf);
-
-    msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(pk, size);
-    {
-        int idx = 0;
-        for (; idx < size; ++idx)
-            msgpack_pack_uint32(pk, 1);
-    }
-    msgpack_packer_free(pk);
-
-
-    size_t upk_pos = 0;
-    msgpack_unpacked msg;
-    msgpack_unpacked_init(&msg);
-
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-    }
-
-    msgpack_sbuffer_destroy(&buf);
-}
-
-int main(int argc, char **argv)
-{
-    int i = 0;
-    for (; i < 10; ++i) test();
-    return 0;
-}

example/c/speed_test_uint64_array.c

@@ -1,37 +0,0 @@
-#include <msgpack.h>
-#include <assert.h>
-
-void test()
-{
-    uint64_t test_u64 = 0xFFF0000000000001LL;
-    size_t size = 10000000;
-    msgpack_sbuffer buf;
-    msgpack_sbuffer_init(&buf);
-
-    msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(pk, size);
-    {
-        int idx = 0;
-        for (; idx < size; ++idx)
-            msgpack_pack_uint64(pk, test_u64);
-    }
-    msgpack_packer_free(pk);
-
-
-    size_t upk_pos = 0;
-    msgpack_unpacked msg;
-    msgpack_unpacked_init(&msg);
-
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-    }
-
-    msgpack_sbuffer_destroy(&buf);
-}
-
-int main(int argc, char **argv)
-{
-    int i = 0;
-    for (; i < 10; ++i) test();
-    return 0;
-}

example/c/user_buffer_unpack.c

@@ -1,75 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-#include <assert.h>
-
-void prepare(msgpack_sbuffer* sbuf) {
-    msgpack_packer pk;
-
-    msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write);
-    /* 1st object */
-    msgpack_pack_array(&pk, 3);
-    msgpack_pack_int(&pk, 1);
-    msgpack_pack_true(&pk);
-    msgpack_pack_str(&pk, 7);
-    msgpack_pack_str_body(&pk, "example", 7);
-    /* 2nd object */
-    msgpack_pack_str(&pk, 6);
-    msgpack_pack_str_body(&pk, "second", 6);
-    /* 3rd object */
-    msgpack_pack_array(&pk, 2);
-    msgpack_pack_int(&pk, 42);
-    msgpack_pack_false(&pk);
-}
-
-void unpack(char const* buf, size_t len) {
-    /* buf is allocated by client. */
-    msgpack_unpacked result;
-    size_t off = 0;
-    msgpack_unpack_return ret;
-    int i = 0;
-    msgpack_unpacked_init(&result);
-    ret = msgpack_unpack_next(&result, buf, len, &off);
-    while (ret == MSGPACK_UNPACK_SUCCESS) {
-        msgpack_object obj = result.data;
-
-        /* Use obj. */
-        printf("Object no %d:\n", i++);
-        msgpack_object_print(stdout, obj);
-        printf("\n");
-        /* If you want to allocate something on the zone, you can use zone. */
-        /* msgpack_zone* zone = result.zone; */
-        /* The lifetime of the obj and the zone,  */
-
-        ret = msgpack_unpack_next(&result, buf, len, &off);
-    }
-    msgpack_unpacked_destroy(&result);
-
-    if (ret == MSGPACK_UNPACK_CONTINUE) {
-        printf("All msgpack_object in the buffer is consumed.\n");
-    }
-    else if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
-        printf("The data in the buf is invalid format.\n");
-    }
-}
-
-int main(void) {
-    msgpack_sbuffer sbuf;
-    msgpack_sbuffer_init(&sbuf);
-
-    prepare(&sbuf);
-    unpack(sbuf.data, sbuf.size);
-
-    msgpack_sbuffer_destroy(&sbuf);
-    return 0;
-}
-
-/* Output */
-
-/*
-Object no 1:
-[1, true, "example"]
-Object no 2:
-"second"
-Object no 3:
-[42, false]
-*/

example/cpp03/class_intrusive.cpp

@@ -1,83 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#include <string>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <cassert>
-
-// msgpack.hpp is also ok
-#include <msgpack_fwd.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) {}
-
-    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(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;
-}
-
-#include <msgpack.hpp>
-
-int main() {
-    {   // pack, unpack
-        my_class my("John Smith", 42);
-        std::stringstream ss;
-        msgpack::pack(ss, my);
-
-        print(ss.str());
-
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.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);
-    }
-}

example/cpp03/class_non_intrusive.cpp

@@ -1,139 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#include <string>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <cassert>
-
-// msgpack.hpp should be included at after user declarations
-#include <msgpack_fwd.hpp>
-
-
-// declarations
-class my_class;
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
-
-object const& operator>> (msgpack::object const& o, my_class& v);
-
-template <typename Stream>
-packer<Stream>& operator<< (msgpack::packer<Stream>& o, my_class const& v);
-
-void operator<< (msgpack::object::with_zone& o, my_class const& v);
-
-} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
-} // namespace msgpack
-
-#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_;
-};
-
-
-// definitions
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
-
-inline object const& operator>> (msgpack::object const& o, my_class& v) {
-    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 <typename Stream>
-inline packer<Stream>& operator<< (msgpack::packer<Stream>& o, my_class const& v) {
-    // packing member variables as an array.
-    o.pack_array(2);
-    o.pack(v.get_name());
-    o.pack(v.get_age());
-    return o;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, my_class const& v) {
-    o.type = type::ARRAY;
-    o.via.array.size = 2;
-    o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object) * o.via.array.size));
-    o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
-    o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
-}
-
-} // 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);
-
-        print(ss.str());
-
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.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);
-    }
-}

example/cpp03/custom.cpp

@@ -1,75 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#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::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.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::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.get();
-
-        obj.convert(&oc);
-
-        std::cout << obj << " value=" << oc.value << std::endl;
-    }
-}

example/cpp03/enum.cpp

@@ -1,68 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#include <msgpack_fwd.hpp>
-#include <sstream>
-#include <iostream>
-#include <cassert>
-
-enum my_enum {
-    elem1,
-    elem2,
-    elem3
-};
-
-MSGPACK_ADD_ENUM(my_enum);
-
-#include <msgpack.hpp>
-
-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::unpacked result;
-        std::size_t off = 0;
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem1);
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem2);
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.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);
-    }
-}

example/cpp03/protocol.cpp

@@ -1,103 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-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::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.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::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
-
-
-        myprotocol::MultiGet req;
-        o.convert(req);
-        std::cout << "received: " << o << std::endl;
-    }
-}

example/cpp03/reuse_zone.cpp

@@ -1,47 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#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.
-    msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
-    assert(obj.as<std::vector<int> >() == v);
-
-    // msgpack str is constructed on z.
-    assert(msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>() == s);
-}

example/cpp03/simple.cpp

@@ -1,54 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#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::unpacked result;
-
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.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;
-}

example/cpp03/speed_test.cpp

@@ -1,71 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2013-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-// 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::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, 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;
-        unpacked.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();
-}

example/cpp03/speed_test_nested_array.cpp

@@ -1,94 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2013-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-// 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 (int 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 (int 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 = 16;
-    std::cout << "Setting up array data..." << std::endl;
-    typename 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::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, str.data(), str.size());
-        std::string result = timer.format();
-        std::cout << result << std::endl;
-    }
-    std::cout << "Unpack finished..." << std::endl;
-    typename vecvec<int, depth>::type v2;
-    std::cout << "Start converting..." << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        unpacked.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();
-}

example/cpp03/stream.cpp

@@ -1,150 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#include <msgpack.hpp>
-#include <iostream>
-#include <stdexcept>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-#include <pthread.h>
-
-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::unpacked result;
-        while (m_pac.next(&result)) {
-            msgpack::object msg = result.get();
-            unique_zone& life = result.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];
-    pipe(pair);
-
-    // 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);
-}

example/cpp11/container.cpp

@@ -1,108 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#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::unpacked und = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object obj = und.get();
-    std::array<int, 5> const& new_a = obj.as<std::array<int, 5>>();
-
-    assert(new_a == a);
-}
-
-void tuple() {
-    std::tuple<bool, std::string, int> t(true, "ABC", 42);
-    std::stringstream ss;
-    msgpack::pack(ss, t);
-
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
-    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 und = msgpack::unpack(ss.str().data(), ss.str().size());
-    assert(und.get().as<decltype(m)>() == m);
-}
-
-void unordered_set() {
-    std::unordered_set<std::string> s { "ABC", "DEF" };
-    std::stringstream ss;
-    msgpack::pack(ss, s);
-
-    assert(msgpack::unpack(ss.str().data(), ss.str().size()).get().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);
-
-    assert(msgpack::unpack(ss.str().data(), ss.str().size()).get().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;
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(a)>() == a);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(t)>() == t);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(m)>() == m);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(s)>() == s);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(f)>() == f);
-}
-
-int main() {
-    array();
-    tuple();
-    unordered_map();
-    unordered_set();
-    forward_list();
-    combi();
-}

include/msgpack.h

@@ -1,32 +0,0 @@
-/*
- * MessagePack for C
- *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-/**
- * @defgroup msgpack MessagePack C
- * @{
- * @}
- */
-
-#include "msgpack/util.h"
-#include "msgpack/object.h"
-#include "msgpack/zone.h"
-#include "msgpack/pack.h"
-#include "msgpack/unpack.h"
-#include "msgpack/sbuffer.h"
-#include "msgpack/vrefbuffer.h"
-#include "msgpack/version.h"
-

include/msgpack.hpp

@@ -1,25 +0,0 @@
-//
-// MessagePack for C++
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#include "msgpack/object.hpp"
-#include "msgpack/iterator.hpp"
-#include "msgpack/zone.hpp"
-#include "msgpack/pack.hpp"
-#include "msgpack/unpack.hpp"
-#include "msgpack/sbuffer.hpp"
-#include "msgpack/vrefbuffer.hpp"
-#include "msgpack/version.hpp"

include/msgpack/adaptor/bool.hpp

@@ -1,58 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_BOOL_HPP
-#define MSGPACK_TYPE_BOOL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-inline msgpack::object const& operator>> (msgpack::object const& o, bool& v)
-{
-    if(o.type != msgpack::type::BOOLEAN) { throw msgpack::type_error(); }
-    v = o.via.boolean;
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const bool& v)
-{
-    if(v) { o.pack_true(); }
-    else { o.pack_false(); }
-    return o;
-}
-
-inline void operator<< (msgpack::object& o, bool v)
-{
-    o.type = msgpack::type::BOOLEAN;
-    o.via.boolean = v;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, bool v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_BOOL_HPP

include/msgpack/adaptor/bool_fwd.hpp

@@ -1,39 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_BOOL_FWD_HPP
-#define MSGPACK_TYPE_BOOL_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-msgpack::object const& operator>> (msgpack::object const& o, bool& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const bool& v);
-void operator<< (msgpack::object& o, bool v);
-void operator<< (msgpack::object::with_zone& o, bool v);
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_BOOL_FWD_HPP

include/msgpack/adaptor/char_ptr.hpp

@@ -1,78 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_CHAR_PTR_HPP
-#define MSGPACK_TYPE_CHAR_PTR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <cstring>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const char* v)
-{
-    uint32_t size = checked_get_container_size(std::strlen(v));
-    o.pack_str(size);
-    o.pack_str_body(v, size);
-    return o;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, const char* v)
-{
-    uint32_t size = checked_get_container_size(std::strlen(v));
-    o.type = msgpack::type::STR;
-    char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-    o.via.str.ptr = ptr;
-    o.via.str.size = size;
-    std::memcpy(ptr, v, size);
-}
-
-inline void operator<< (msgpack::object& o, const char* v)
-{
-    uint32_t size = checked_get_container_size(std::strlen(v));
-    o.type = msgpack::type::STR;
-    o.via.str.ptr = v;
-    o.via.str.size = size;
-}
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, char* v)
-{
-    return msgpack::operator<<(o, static_cast<const char*>(v));
-}
-
-inline void operator<< (object::with_zone& o, char* v)
-{
-    msgpack::operator<<(o, static_cast<const char*>(v));
-}
-
-inline void operator<< (object& o, char* v)
-{
-    msgpack::operator<<(o, static_cast<const char*>(v));
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_CHAR_PTR_HPP

include/msgpack/adaptor/char_ptr_fwd.hpp

@@ -1,43 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_CHAR_PTR_FWD_HPP
-#define MSGPACK_TYPE_CHAR_PTR_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <cstring>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const char* v);
-void operator<< (msgpack::object::with_zone& o, const char* v);
-void operator<< (msgpack::object& o, const char* v);
-
-template <typename Stream>
-packer<Stream>& operator<< (packer<Stream>& o, char* v);
-void operator<< (object::with_zone& o, char* v);
-void operator<< (object& o, char* v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_CHAR_PTR_FWD_HPP

include/msgpack/adaptor/check_container_size.hpp

@@ -1,61 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP
-#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
-
-#include "msgpack/versioning.hpp"
-#include <stdexcept>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-struct container_size_overflow : public std::runtime_error {
-    explicit container_size_overflow(const std::string& msg)
-        :std::runtime_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit container_size_overflow(const char* msg):
-        std::runtime_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-namespace detail {
-
-template <std::size_t N>
-inline void check_container_size(std::size_t size) {
-    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
-}
-
-template <>
-inline void check_container_size<4>(std::size_t size) {
-}
-
-} // namespace detail
-
-template <typename T>
-inline uint32_t checked_get_container_size(T size) {
-    detail::check_container_size<sizeof(T)>(size);
-    return static_cast<uint32_t>(size);
-}
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

include/msgpack/adaptor/cpp11/array.hpp

@@ -1,76 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#ifndef MSGPACK_CPP11_ARRAY_HPP
-#define MSGPACK_CPP11_ARRAY_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T, std::size_t N>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::array<T, N>& v) {
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size != N) { throw msgpack::type_error(); }
-    if(o.via.array.size > 0) {
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        T* it = &v[0];
-        do {
-            p->convert(*it);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-    return o;
-}
-
-template <typename Stream, typename T, std::size_t N>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::array<T, N>& v) {
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(auto const& e : v) o.pack(e);
-    return o;
-}
-
-template <typename T, std::size_t N>
-inline void operator<< (msgpack::object::with_zone& o, const std::array<T, N>& v) {
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.size = size;
-        o.via.array.ptr = p;
-        for (auto const& e : v) *p++ = msgpack::object(e, o.zone);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_ARRAY_HPP

include/msgpack/adaptor/cpp11/array_char.hpp

@@ -1,84 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP
-#define MSGPACK_TYPE_ARRAY_CHAR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <std::size_t N>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::array<char, N>& v)
-{
-    switch (o.type) {
-    case msgpack::type::BIN:
-        if(o.via.bin.size != N) { throw msgpack::type_error(); }
-        std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
-        break;
-    case msgpack::type::STR:
-        if(o.via.str.size != N) { throw msgpack::type_error(); }
-        std::memcpy(v.data(), o.via.str.ptr, N);
-        break;
-    default:
-        throw msgpack::type_error();
-        break;
-    }
-    return o;
-}
-
-template <typename Stream, std::size_t N>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::array<char, N>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_bin(size);
-    o.pack_bin_body(v.data(), size);
-
-    return o;
-}
-
-template <std::size_t N>
-inline void operator<< (msgpack::object& o, const std::array<char, N>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.type = msgpack::type::BIN;
-    o.via.bin.ptr = v.data();
-    o.via.bin.size = size;
-}
-
-template <std::size_t N>
-inline void operator<< (msgpack::object::with_zone& o, const std::array<char, N>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.type = msgpack::type::BIN;
-    char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-    o.via.bin.ptr = ptr;
-    o.via.bin.size = size;
-    std::memcpy(ptr, v.data(), size);
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP

include/msgpack/adaptor/cpp11/array_char_fwd.hpp

@@ -1,45 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP
-#define MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <array>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <std::size_t N>
-msgpack::object const& operator>> (msgpack::object const& o, std::array<char, N>& v);
-
-template <typename Stream, std::size_t N>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::array<char, N>& v);
-
-template <std::size_t N>
-void operator<< (msgpack::object& o, const std::array<char, N>& v);
-
-template <std::size_t N>
-void operator<< (msgpack::object::with_zone& o, const std::array<char, N>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP

include/msgpack/adaptor/cpp11/array_fwd.hpp

@@ -1,44 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#ifndef MSGPACK_CPP11_ARRAY_FWD_HPP
-#define MSGPACK_CPP11_ARRAY_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T, std::size_t N>
-msgpack::object const& operator>> (msgpack::object const& o, std::array<T, N>& v);
-
-template <typename Stream, typename T, std::size_t N>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::array<T, N>& v);
-
-template <typename T, std::size_t N>
-void operator<< (msgpack::object::with_zone& o, const std::array<T, N>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_ARRAY_FWD_HPP

include/msgpack/adaptor/cpp11/forward_list.hpp

@@ -1,75 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO-2015 Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP
-#define MSGPACK_CPP11_FORWARD_LIST_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <forward_list>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::forward_list<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    v.resize(o.via.array.size);
-    msgpack::object* p = o.via.array.ptr;
-    for (auto &e : v) {
-        p->convert(e);
-        ++p;
-    }
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::forward_list<T>& v)
-{
-    uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
-    o.pack_array(size);
-    for(auto const& e : v) o.pack(e);
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::forward_list<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
-        o.via.array.size = size;
-        msgpack::object* p = static_cast<msgpack::object*>(
-            o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.ptr = p;
-        for(auto const& e : v) *p++ = msgpack::object(e, o.zone);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_FORWARD_LIST_HPP

include/msgpack/adaptor/cpp11/forward_list_fwd.hpp

@@ -1,44 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-
-#ifndef MSGPACK_CPP11_FORWARD_LIST_FWD_HPP
-#define MSGPACK_CPP11_FORWARD_LIST_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <forward_list>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::forward_list<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::forward_list<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::forward_list<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_FORWARD_LIST_FWD_HPP

include/msgpack/adaptor/cpp11/tuple.hpp

@@ -1,152 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_TUPLE_HPP
-#define MSGPACK_CPP11_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct StdTuplePacker {
-    static void pack(
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        StdTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(std::get<N-1>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct StdTuplePacker<Stream, Tuple, 1> {
-    static void pack (
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        o.pack(std::get<0>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct StdTuplePacker<Stream, Tuple, 0> {
-    static void pack (
-        msgpack::packer<Stream>&,
-        const Tuple&) {
-    }
-};
-
-
-template <typename Stream, typename... Args>
-inline const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const std::tuple<Args...>& v) {
-    uint32_t size = checked_get_container_size(sizeof...(Args));
-    o.pack_array(size);
-    StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-    return o;
-}
-
-// --- Convert from tuple to object ---
-
-template <typename Tuple, std::size_t N>
-struct StdTupleConverter {
-    static void convert(
-        msgpack::object const& o,
-        Tuple& v) {
-        StdTupleConverter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v));
-    }
-};
-
-template <typename Tuple>
-struct StdTupleConverter<Tuple, 1> {
-    static void convert (
-        msgpack::object const& o,
-        Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(std::get<0>(v))>::type>(std::get<0>(v));
-    }
-};
-
-template <typename Tuple>
-struct StdTupleConverter<Tuple, 0> {
-    static void convert (
-        msgpack::object const&,
-        Tuple&) {
-    }
-};
-
-template <typename... Args>
-inline msgpack::object const& operator>> (
-    msgpack::object const& o,
-    std::tuple<Args...>& v) {
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-    StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return o;
-}
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct StdTupleToObjectWithZone {
-    static void convert(
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(std::get<N-1>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct StdTupleToObjectWithZone<Tuple, 1> {
-    static void convert (
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        o.via.array.ptr[0] = msgpack::object(std::get<0>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct StdTupleToObjectWithZone<Tuple, 0> {
-    static void convert (
-        msgpack::object::with_zone&,
-        const Tuple&) {
-    }
-};
-
-template <typename... Args>
-inline void operator<< (
-        msgpack::object::with_zone& o,
-        std::tuple<Args...> const& v) {
-    uint32_t size = checked_get_container_size(sizeof...(Args));
-    o.type = msgpack::type::ARRAY;
-    o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-    o.via.array.size = size;
-    StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-}
-
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_TUPLE_HPP

include/msgpack/adaptor/cpp11/tuple_fwd.hpp

@@ -1,62 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_TUPLE_FWD_HPP
-#define MSGPACK_CPP11_TUPLE_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct StdTuplePacker;
-
-template <typename Stream, typename... Args>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const std::tuple<Args...>& v);
-
-// --- Convert from tuple to object ---
-
-template <typename Tuple, std::size_t N>
-struct StdTupleConverter;
-
-template <typename... Args>
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    std::tuple<Args...>& v);
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct StdTupleToObjectWithZone;
-
-template <typename... Args>
-void operator<< (
-    msgpack::object::with_zone& o,
-    std::tuple<Args...> const& v);
-
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_TUPLE_FWD_HPP

include/msgpack/adaptor/cpp11/unordered_map.hpp

@@ -1,142 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_UNORDERED_MAP_HPP
-#define MSGPACK_TYPE_UNORDERED_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <unordered_map>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::unordered_map<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    std::unordered_map<K, V> tmp;
-    for(; p != pend; ++p) {
-        K key;
-        p->key.convert(key);
-        p->val.convert(tmp[key]);
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_map<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename std::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const std::unordered_map<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename std::unordered_map<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::unordered_multimap<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    std::unordered_multimap<K, V> tmp;
-    for(; p != pend; ++p) {
-        std::pair<K, V> value;
-        p->key.convert(value.first);
-        p->val.convert(value.second);
-        tmp.insert(value);
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_multimap<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename std::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const std::unordered_multimap<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename std::unordered_multimap<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-
-#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP

include/msgpack/adaptor/cpp11/unordered_map_fwd.hpp

@@ -1,53 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_UNORDERED_MAP_FWD_HPP
-#define MSGPACK_TYPE_UNORDERED_MAP_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <unordered_map>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, std::unordered_map<K, V>& v);
-
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_map<K,V>& v);
-
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const std::unordered_map<K,V>& v);
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, std::unordered_multimap<K, V>& v);
-
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_multimap<K,V>& v);
-
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const std::unordered_multimap<K,V>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-
-#endif // MSGPACK_TYPE_UNORDERED_MAP_FWD_HPP

include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -1,134 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_UNORDERED_SET_HPP
-#define MSGPACK_TYPE_UNORDERED_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <unordered_set>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::unordered_set<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::unordered_set<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_set<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::unordered_set<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::unordered_set<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::unordered_multiset<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::unordered_multiset<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_multiset<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::unordered_multiset<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::unordered_multiset<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_UNORDERED_SET_HPP

include/msgpack/adaptor/cpp11/unordered_set_fwd.hpp

@@ -1,52 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_UNORDERED_SET_FWD_HPP
-#define MSGPACK_TYPE_UNORDERED_SET_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <unordered_set>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::unordered_set<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_set<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::unordered_set<T>& v);
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::unordered_multiset<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::unordered_multiset<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::unordered_multiset<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_UNORDERED_SET_FWD_HPP

include/msgpack/adaptor/define.hpp

@@ -1,29 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_DEFINE_HPP
-#define MSGPACK_DEFINE_HPP
-
-#include "msgpack/cpp_config.hpp"
-
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_define.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_define.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#endif // MSGPACK_DEFINE_HPP

include/msgpack/adaptor/deque.hpp

@@ -1,83 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_DEQUE_HPP
-#define MSGPACK_TYPE_DEQUE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <deque>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::deque<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    v.resize(o.via.array.size);
-    msgpack::object* p = o.via.array.ptr;
-    msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-    typename std::deque<T>::iterator it = v.begin();
-    for(; p < pend; ++p, ++it) {
-        p->convert(*it);
-    }
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::deque<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::deque<T>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::deque<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::deque<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/deque.hpp */

include/msgpack/adaptor/deque_fwd.hpp

@@ -1,40 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_DEQUE_FWD_HPP
-#define MSGPACK_TYPE_DEQUE_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <deque>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::deque<T>& v);
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::deque<T>& v);
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::deque<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_DEQUE_FWD_HPP

include/msgpack/adaptor/detail/cpp11_define.hpp

@@ -1,184 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_DEFINE_HPP
-#define MSGPACK_CPP11_DEFINE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-// for MSGPACK_ADD_ENUM
-#include "msgpack/adaptor/int_fwd.hpp"
-
-#include <type_traits>
-#include <tuple>
-
-#define MSGPACK_DEFINE(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum) \
-  namespace msgpack { \
-  MSGPACK_API_VERSION_NAMESPACE(v1) { \
-    inline msgpack::object const& operator>> (msgpack::object const& o, enum& v) \
-    { \
-      std::underlying_type<enum>::type tmp; \
-      o >> tmp; \
-      v = static_cast<enum>(tmp);   \
-      return o; \
-    } \
-    inline void operator<< (msgpack::object& o, const enum& v) \
-    { \
-      auto tmp = static_cast<std::underlying_type<enum>::type>(v); \
-      o << tmp; \
-    } \
-    inline void operator<< (msgpack::object::with_zone& o, const enum& v) \
-    { \
-      auto tmp = static_cast<std::underlying_type<enum>::type>(v); \
-      o << tmp; \
-    } \
-    namespace detail { \
-      template <typename Stream> \
-      struct packer_serializer<Stream, enum> { \
-        static msgpack::packer<Stream>& pack(msgpack::packer<Stream>& o, const enum& v) { \
-          return o << static_cast<std::underlying_type<enum>::type>(v); \
-        } \
-      }; \
-    } \
-  } \
-  }
-
-namespace msgpack {
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-namespace type {
-
-template <typename Tuple, std::size_t N>
-struct define_imp {
-    template <typename Packer>
-    static void pack(Packer& pk, Tuple const& t) {
-        define_imp<Tuple, N-1>::pack(pk, t);
-        pk.pack(std::get<N-1>(t));
-    }
-    static void unpack(msgpack::object const& o, Tuple& t) {
-        define_imp<Tuple, N-1>::unpack(o, t);
-        const size_t size = o.via.array.size;
-        if(size <= N-1) { return; }
-        o.via.array.ptr[N-1].convert(std::get<N-1>(t));
-    }
-    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        define_imp<Tuple, N-1>::object(o, z, t);
-        o->via.array.ptr[N-1] = msgpack::object(std::get<N-1>(t), z);
-    }
-};
-
-template <typename Tuple>
-struct define_imp<Tuple, 1> {
-    template <typename Packer>
-    static void pack(Packer& pk, Tuple const& t) {
-        pk.pack(std::get<0>(t));
-    }
-    static void unpack(msgpack::object const& o, Tuple& t) {
-        const size_t size = o.via.array.size;
-        if(size <= 0) { return; }
-        o.via.array.ptr[0].convert(std::get<0>(t));
-    }
-    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z);
-    }
-};
-
-template <typename... Args>
-struct define {
-    typedef define<Args...> value_type;
-    typedef std::tuple<Args...> tuple_type;
-    define(Args&... args) :
-        a(args...) {}
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_array(sizeof...(Args));
-
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
-    }
-    void msgpack_unpack(msgpack::object const& o)
-    {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
-    }
-    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)*sizeof...(Args)));
-        o->via.array.size = sizeof...(Args);
-
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
-    }
-
-    std::tuple<Args&...> a;
-};
-
-template <>
-struct define<> {
-    typedef define<> value_type;
-    typedef std::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 = NULL;
-        o->via.array.size = 0;
-    }
-};
-
-inline define<> make_define()
-{
-    return define<>();
-}
-
-template <typename... Args>
-define<Args...> make_define(Args&... args)
-{
-    return define<Args...>(args...);
-}
-
-}  // namespace type
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_DEFINE_HPP

include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -1,212 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP
-#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-    // tuple
-    using std::get;
-    using std::tuple_size;
-    using std::tuple_element;
-    using std::uses_allocator;
-    using std::ignore;
-    using std::make_tuple;
-    using std::tie;
-    using std::forward_as_tuple;
-    using std::swap;
-
-    template< class... Types >
-    class tuple : public std::tuple<Types...> {
-    public:
-        using base = std::tuple<Types...>;
-
-        using base::tuple;
-
-        tuple() = default;
-        tuple(tuple const&) = default;
-        tuple(tuple&&) = default;
-
-        template<typename... OtherTypes>
-        tuple(tuple<OtherTypes...> const& other):base(static_cast<std::tuple<OtherTypes...> const&>(other)) {}
-        template<typename... OtherTypes>
-        tuple(tuple<OtherTypes...> && other):base(static_cast<std::tuple<OtherTypes...> &&>(other)) {}
-
-        tuple& operator=(tuple const&) = default;
-        tuple& operator=(tuple&&) = default;
-
-        template<typename... OtherTypes>
-        tuple& operator=(tuple<OtherTypes...> const& other) {
-            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> const&>(other);
-            return *this;
-        }
-        template<typename... OtherTypes>
-        tuple& operator=(tuple<OtherTypes...> && other) {
-            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> &&>(other);
-            return *this;
-        }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&
-        get() { return std::get<I>(*this); }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type const&
-        get() const { return std::get<I>(*this); }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&&
-        get() && { return std::get<I>(*this); }
-    };
-
-    template< class... Tuples >
-    auto tuple_cat(Tuples&&... args) ->
-        decltype(
-            std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
-        ) {
-        return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...);
-    }
-} // namespace type
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct MsgpackTuplePacker {
-    static void pack(
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        MsgpackTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(type::get<N-1>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct MsgpackTuplePacker<Stream, Tuple, 1> {
-    static void pack (
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        o.pack(type::get<0>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct MsgpackTuplePacker<Stream, Tuple, 0> {
-    static void pack (
-        msgpack::packer<Stream>&,
-        const Tuple&) {
-    }
-};
-
-template <typename Stream, typename... Args>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const type::tuple<Args...>& v) {
-    o.pack_array(sizeof...(Args));
-    MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-    return o;
-}
-
-// --- Convert from tuple to object ---
-
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleConverter {
-    static void convert(
-        msgpack::object const& o,
-        Tuple& v) {
-        MsgpackTupleConverter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v));
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleConverter<Tuple, 1> {
-    static void convert (
-        msgpack::object const& o,
-        Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(type::get<0>(v));
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleConverter<Tuple, 0> {
-    static void convert (
-        msgpack::object const&,
-        Tuple&) {
-    }
-};
-
-template <typename... Args>
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    type::tuple<Args...>& v) {
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-    MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return o;
-}
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleToObjectWithZone {
-    static void convert(
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        MsgpackTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(type::get<N-1>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleToObjectWithZone<Tuple, 1> {
-    static void convert (
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        o.via.array.ptr[0] = msgpack::object(type::get<0>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleToObjectWithZone<Tuple, 0> {
-    static void convert (
-        msgpack::object::with_zone&,
-        const Tuple&) {
-    }
-};
-
-template <typename... Args>
-inline void operator<< (
-        msgpack::object::with_zone& o,
-        type::tuple<Args...> const& v) {
-    o.type = msgpack::type::ARRAY;
-    o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
-    o.via.array.size = sizeof...(Args);
-    MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp

@@ -1,84 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP
-#define MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-    // tuple
-    using std::get;
-    using std::tuple_size;
-    using std::tuple_element;
-    using std::uses_allocator;
-    using std::ignore;
-    using std::make_tuple;
-    using std::tie;
-    using std::forward_as_tuple;
-    using std::swap;
-
-    template< class... Types >
-    class tuple;
-
-    template< class... Tuples >
-    auto tuple_cat(Tuples&&... args) ->
-        decltype(
-            std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
-        );
-} // namespace type
-
-// --- Pack ( from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct MsgpackTuplePacker;
-
-template <typename Stream, typename... Args>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const type::tuple<Args...>& v);
-
-// --- Convert from tuple to object ---
-
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleConverter;
-
-template <typename... Args>
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    type::tuple<Args...>& v);
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleToObjectWithZone;
-
-template <typename... Args>
-void operator<< (
-    msgpack::object::with_zone& o,
-    type::tuple<Args...> const& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP

include/msgpack/adaptor/fixint.hpp

@@ -1,212 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2020 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_FIXINT_HPP
-#define MSGPACK_TYPE_FIXINT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/int.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-
-template <typename T>
-struct fix_int {
-    fix_int() : value(0) { }
-    fix_int(T value) : value(value) { }
-
-    operator T() const { return value; }
-
-    T get() const { return value; }
-
-private:
-    T value;
-};
-
-
-typedef fix_int<uint8_t>  fix_uint8;
-typedef fix_int<uint16_t> fix_uint16;
-typedef fix_int<uint32_t> fix_uint32;
-typedef fix_int<uint64_t> fix_uint64;
-
-typedef fix_int<int8_t>  fix_int8;
-typedef fix_int<int16_t> fix_int16;
-typedef fix_int<int32_t> fix_int32;
-typedef fix_int<int64_t> fix_int64;
-
-
-}  // namespace type
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_int8& v)
-    { v = type::detail::convert_integer<int8_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_int16& v)
-    { v = type::detail::convert_integer<int16_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_int32& v)
-    { v = type::detail::convert_integer<int32_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_int64& v)
-    { v = type::detail::convert_integer<int64_t>(o); return o; }
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint8& v)
-    { v = type::detail::convert_integer<uint8_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint16& v)
-    { v = type::detail::convert_integer<uint16_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint32& v)
-    { v = type::detail::convert_integer<uint32_t>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint64& v)
-    { v = type::detail::convert_integer<uint64_t>(o); return o; }
-
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int8& v)
-    { o.pack_fix_int8(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int16& v)
-    { o.pack_fix_int16(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int32& v)
-    { o.pack_fix_int32(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int64& v)
-    { o.pack_fix_int64(v); return o; }
-
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint8& v)
-    { o.pack_fix_uint8(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint16& v)
-    { o.pack_fix_uint16(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint32& v)
-    { o.pack_fix_uint32(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint64& v)
-    { o.pack_fix_uint64(v); return o; }
-
-
-inline void operator<< (msgpack::object& o, type::fix_int8 v)
-{
-    if (v.get() < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v.get();
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v.get();
-    }
-}
-
-inline void operator<< (msgpack::object& o, type::fix_int16 v)
-{
-    if(v.get() < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v.get();
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v.get();
-    }
-}
-
-inline void operator<< (msgpack::object& o, type::fix_int32 v)
-{
-    if (v.get() < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v.get();
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v.get();
-    }
-}
-
-inline void operator<< (msgpack::object& o, type::fix_int64 v)
-{
-    if (v.get() < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v.get();
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v.get();
-    }
-}
-
-
-inline void operator<< (msgpack::object& o, type::fix_uint8 v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (msgpack::object& o, type::fix_uint16 v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (msgpack::object& o, type::fix_uint32 v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (msgpack::object& o, type::fix_uint64 v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_int8 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_int16 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_int32 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_int64 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_uint8 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_uint16 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_uint32 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, type::fix_uint64 v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/fixint.hpp */

include/msgpack/adaptor/fixint_fwd.hpp

@@ -1,100 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_FIXINT_FWD_HPP
-#define MSGPACK_TYPE_FIXINT_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-
-template <typename T>
-struct fix_int;
-
-typedef fix_int<uint8_t>  fix_uint8;
-typedef fix_int<uint16_t> fix_uint16;
-typedef fix_int<uint32_t> fix_uint32;
-typedef fix_int<uint64_t> fix_uint64;
-
-typedef fix_int<int8_t>  fix_int8;
-typedef fix_int<int16_t> fix_int16;
-typedef fix_int<int32_t> fix_int32;
-typedef fix_int<int64_t> fix_int64;
-
-
-}  // namespace type
-
-
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_int8& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_int16& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_int32& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_int64& v);
-
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint8& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint16& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint32& v);
-msgpack::object const& operator>> (msgpack::object const& o, type::fix_uint64& v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int8& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int16& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int32& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_int64& v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint8& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint16& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint32& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::fix_uint64& v);
-
-void operator<< (msgpack::object& o, type::fix_int8 v);
-void operator<< (msgpack::object& o, type::fix_int16 v);
-void operator<< (msgpack::object& o, type::fix_int32 v);
-void operator<< (msgpack::object& o, type::fix_int64 v);
-
-void operator<< (msgpack::object& o, type::fix_uint8 v);
-void operator<< (msgpack::object& o, type::fix_uint16 v);
-void operator<< (msgpack::object& o, type::fix_uint32 v);
-void operator<< (msgpack::object& o, type::fix_uint64 v);
-
-void operator<< (msgpack::object::with_zone& o, type::fix_int8 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_int16 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_int32 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_int64 v);
-
-void operator<< (msgpack::object::with_zone& o, type::fix_uint8 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_uint16 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_uint32 v);
-void operator<< (msgpack::object::with_zone& o, type::fix_uint64 v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_FIXINT_FWD_HPP

include/msgpack/adaptor/float.hpp

@@ -1,105 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_FLOAT_HPP
-#define MSGPACK_TYPE_FLOAT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-// FIXME check overflow, underflow
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, float& v)
-{
-    if(o.type == msgpack::type::FLOAT) {
-        v = static_cast<float>(o.via.f64);
-    }
-    else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-        v = static_cast<float>(o.via.u64);
-    }
-    else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-        v = static_cast<float>(o.via.i64);
-    }
-    else {
-        throw msgpack::type_error();
-    }
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const float& v)
-{
-    o.pack_float(v);
-    return o;
-}
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, double& v)
-{
-    if(o.type == msgpack::type::FLOAT) {
-        v = o.via.f64;
-    }
-    else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-        v = static_cast<double>(o.via.u64);
-    }
-    else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-        v = static_cast<double>(o.via.i64);
-    }
-    else {
-        throw msgpack::type_error();
-    }
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const double& v)
-{
-    o.pack_double(v);
-    return o;
-}
-
-
-inline void operator<< (msgpack::object& o, float v)
-{
-    o.type = msgpack::type::FLOAT;
-    o.via.f64 = static_cast<double>(v);
-}
-
-inline void operator<< (msgpack::object& o, double v)
-{
-    o.type = msgpack::type::FLOAT;
-    o.via.f64 = v;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, float v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, double v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_FLOAT_HPP

include/msgpack/adaptor/float_fwd.hpp

@@ -1,44 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_FLOAT_FWD_HPP
-#define MSGPACK_TYPE_FLOAT_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-msgpack::object const& operator>> (msgpack::object const& o, float& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const float& v);
-msgpack::object const& operator>> (msgpack::object const& o, double& v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const double& v);
-void operator<< (msgpack::object& o, float v);
-void operator<< (msgpack::object& o, double v);
-void operator<< (msgpack::object::with_zone& o, float v);
-void operator<< (msgpack::object::with_zone& o, double v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_FLOAT_FWD_HPP

include/msgpack/adaptor/int.hpp

@@ -1,308 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_INT_HPP
-#define MSGPACK_TYPE_INT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack_fwd.hpp"
-#include <limits>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1){
-
-namespace type {
-namespace detail {
-    template <typename T, bool Signed>
-    struct convert_integer_sign;
-
-    template <typename T>
-    struct convert_integer_sign<T, true> {
-        static inline T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            } else if(o.type == msgpack::type::NEGATIVE_INTEGER) {
-                if(o.via.i64 < static_cast<int64_t>(std::numeric_limits<T>::min()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.i64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct convert_integer_sign<T, false> {
-        static inline T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct is_signed {
-        static const bool value = std::numeric_limits<T>::is_signed;
-    };
-
-    template <typename T>
-    static inline T convert_integer(msgpack::object const& o)
-    {
-        return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
-    }
-
-    template <bool Signed>
-    struct object_char_sign;
-
-    template <>
-    struct object_char_sign<true> {
-        static inline void make(msgpack::object& o, char v) {
-            if (v < 0) {
-                o.type = msgpack::type::NEGATIVE_INTEGER;
-                o.via.i64 = v;
-            }
-            else {
-                o.type = msgpack::type::POSITIVE_INTEGER;
-                o.via.u64 = v;
-            }
-        }
-    };
-
-    template <>
-    struct object_char_sign<false> {
-        static inline void make(msgpack::object& o, char v) {
-            o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v;
-        }
-    };
-
-    static inline void object_char(msgpack::object& o, char v) {
-        return object_char_sign<is_signed<char>::value>::make(o, v);
-    }
-
-}  // namespace detail
-}  // namespace type
-
-inline msgpack::object const& operator>> (msgpack::object const& o, char& v)
-    { v = type::detail::convert_integer<char>(o); return o; }
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, signed char& v)
-    { v = type::detail::convert_integer<signed char>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, signed short& v)
-    { v = type::detail::convert_integer<signed short>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, signed int& v)
-    { v = type::detail::convert_integer<signed int>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, signed long& v)
-    { v = type::detail::convert_integer<signed long>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, signed long long& v)
-    { v = type::detail::convert_integer<signed long long>(o); return o; }
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, unsigned char& v)
-    { v = type::detail::convert_integer<unsigned char>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, unsigned short& v)
-    { v = type::detail::convert_integer<unsigned short>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, unsigned int& v)
-    { v = type::detail::convert_integer<unsigned int>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, unsigned long& v)
-    { v = type::detail::convert_integer<unsigned long>(o); return o; }
-
-inline msgpack::object const& operator>> (msgpack::object const& o, unsigned long long& v)
-    { v = type::detail::convert_integer<unsigned long long>(o); return o; }
-
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, char v)
-    { o.pack_char(v); return o; }
-
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed char v)
-    { o.pack_signed_char(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed short v)
-    { o.pack_short(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed int v)
-    { o.pack_int(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed long v)
-    { o.pack_long(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed long long v)
-    { o.pack_long_long(v); return o; }
-
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned char v)
-    { o.pack_unsigned_char(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned short v)
-    { o.pack_unsigned_short(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned int v)
-    { o.pack_unsigned_int(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned long v)
-    { o.pack_unsigned_long(v); return o; }
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned long long v)
-    { o.pack_unsigned_long_long(v); return o; }
-
-
-inline void operator<< (msgpack::object& o, char v)
-    { type::detail::object_char(o, v); }
-
-
-inline void operator<< (msgpack::object& o, signed char v)
-{
-    if (v < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v;
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v;
-    }
-}
-
-inline void operator<< (msgpack::object& o, signed short v)
-{
-    if (v < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v;
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v;
-    }
-}
-
-inline void operator<< (msgpack::object& o, signed int v)
-{
-    if (v < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v;
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v;
-    }
-}
-
-inline void operator<< (msgpack::object& o, signed long v)
-{
-    if (v < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v;
-    }
-    else {
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v;
-    }
-}
-
-inline void operator<< (msgpack::object& o, signed long long v)
-{
-    if (v < 0) {
-        o.type = msgpack::type::NEGATIVE_INTEGER;
-        o.via.i64 = v;
-    }
-    else{
-        o.type = msgpack::type::POSITIVE_INTEGER;
-        o.via.u64 = v;
-    }
-}
-
-inline void operator<< (msgpack::object& o, unsigned char v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (msgpack::object& o, unsigned short v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (msgpack::object& o, unsigned int v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (msgpack::object& o, unsigned long v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (msgpack::object& o, unsigned long long v)
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-
-
-inline void operator<< (msgpack::object::with_zone& o, char v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-inline void operator<< (msgpack::object::with_zone& o, signed char v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, signed short v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, signed int v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, signed long v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, const signed long long& v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-inline void operator<< (msgpack::object::with_zone& o, unsigned char v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, unsigned short v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, unsigned int v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, unsigned long v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-inline void operator<< (msgpack::object::with_zone& o, const unsigned long long& v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/int.hpp */

include/msgpack/adaptor/int_fwd.hpp

@@ -1,100 +0,0 @@
-//
-// MessagePack for C++ forward declaration
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_INT_FWD_HPP
-#define MSGPACK_TYPE_INT_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1){
-
-msgpack::object const& operator>> (msgpack::object const& o, char& v);
-
-msgpack::object const& operator>> (msgpack::object const& o, signed char& v);
-msgpack::object const& operator>> (msgpack::object const& o, signed short& v);
-msgpack::object const& operator>> (msgpack::object const& o, signed int& v);
-msgpack::object const& operator>> (msgpack::object const& o, signed long& v);
-msgpack::object const& operator>> (msgpack::object const& o, signed long long& v);
-
-msgpack::object const& operator>> (msgpack::object const& o, unsigned char& v);
-msgpack::object const& operator>> (msgpack::object const& o, unsigned short& v);
-msgpack::object const& operator>> (msgpack::object const& o, unsigned int& v);
-msgpack::object const& operator>> (msgpack::object const& o, unsigned long& v);
-msgpack::object const& operator>> (msgpack::object const& o, unsigned long long& v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, char v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed char v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed short v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed int v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed long v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, signed long long v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned char v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned short v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned int v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned long v);
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, unsigned long long v);
-
-
-void operator<< (msgpack::object& o, char v);
-
-void operator<< (msgpack::object& o, signed char v);
-void operator<< (msgpack::object& o, signed short v);
-void operator<< (msgpack::object& o, signed int v);
-void operator<< (msgpack::object& o, signed long v);
-void operator<< (msgpack::object& o, signed long long v);
-
-void operator<< (msgpack::object& o, unsigned char v);
-void operator<< (msgpack::object& o, unsigned short v);
-void operator<< (msgpack::object& o, unsigned int v);
-void operator<< (msgpack::object& o, unsigned long v);
-void operator<< (msgpack::object& o, unsigned long long v);
-
-void operator<< (msgpack::object::with_zone& o, char v);
-
-void operator<< (msgpack::object::with_zone& o, signed char v);
-void operator<< (msgpack::object::with_zone& o, signed short v);
-void operator<< (msgpack::object::with_zone& o, signed int v);
-void operator<< (msgpack::object::with_zone& o, signed long v);
-void operator<< (msgpack::object::with_zone& o, const signed long long& v);
-
-void operator<< (msgpack::object::with_zone& o, unsigned char v);
-void operator<< (msgpack::object::with_zone& o, unsigned short v);
-void operator<< (msgpack::object::with_zone& o, unsigned int v);
-void operator<< (msgpack::object::with_zone& o, unsigned long v);
-void operator<< (msgpack::object::with_zone& o, const unsigned long long& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_INT_FWD_HPP

include/msgpack/adaptor/list.hpp

@@ -1,83 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_LIST_HPP
-#define MSGPACK_TYPE_LIST_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <list>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::list<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    v.resize(o.via.array.size);
-    msgpack::object* p = o.via.array.ptr;
-    msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-    typename std::list<T>::iterator it = v.begin();
-    for(; p < pend; ++p, ++it) {
-        p->convert(*it);
-    }
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::list<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::list<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::list<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::list<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_LIST_HPP

include/msgpack/adaptor/list_fwd.hpp

@@ -1,40 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_LIST_FWD_HPP
-#define MSGPACK_TYPE_LIST_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <list>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::list<T>& v);
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::list<T>& v);
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::list<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_LIST_FWD_HPP

include/msgpack/adaptor/map.hpp

@@ -1,219 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_MAP_HPP
-#define MSGPACK_TYPE_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <map>
-#include <vector>
-#include <algorithm>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-template <typename K, typename V>
-class assoc_vector : public std::vector< std::pair<K, V> > {};
-
-namespace detail {
-    template <typename K, typename V>
-    struct pair_first_less {
-        bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
-            { return x.first < y.first; }
-    };
-}
-
-}  //namespace type
-
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, type::assoc_vector<K,V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    v.resize(o.via.map.size);
-    msgpack::object_kv* p = o.via.map.ptr;
-    msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size;
-    std::pair<K, V>* it(&v.front());
-    for(; p < pend; ++p, ++it) {
-        p->key.convert(it->first);
-        p->val.convert(it->second);
-    }
-    std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::assoc_vector<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename type::assoc_vector<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const type::assoc_vector<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename type::assoc_vector<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::map<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    std::map<K, V> tmp;
-    for(; p != pend; ++p) {
-        K key;
-        p->key.convert(key);
-        typename std::map<K,V>::iterator it(tmp.lower_bound(key));
-        if(it != tmp.end() && !(key < it->first)) {
-            p->val.convert(it->second);
-        } else {
-            V val;
-            p->val.convert(val);
-            tmp.insert(it, std::pair<K,V>(key, val));
-        }
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::map<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename std::map<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const std::map<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename std::map<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::multimap<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    std::multimap<K, V> tmp;
-    for(; p != pend; ++p) {
-        std::pair<K, V> value;
-        p->key.convert(value.first);
-        p->val.convert(value.second);
-        tmp.insert(value);
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::multimap<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const std::multimap<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename std::multimap<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_MAP_HPP

include/msgpack/adaptor/map_fwd.hpp

@@ -1,69 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_MAP_FWD_HPP
-#define MSGPACK_TYPE_MAP_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <map>
-#include <vector>
-#include <algorithm>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-template <typename K, typename V>
-class assoc_vector;
-
-namespace detail {
-    template <typename K, typename V>
-    struct pair_first_less;
-}  // namespace detail
-
-}  // namespace type
-
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, type::assoc_vector<K,V>& v);
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::assoc_vector<K,V>& v);
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const type::assoc_vector<K,V>& v);
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, std::map<K, V>& v);
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::map<K,V>& v);
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const std::map<K,V>& v);
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, std::multimap<K, V>& v);
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::multimap<K,V>& v);
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const std::multimap<K,V>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_MAP_HPP

include/msgpack/adaptor/msgpack_tuple.hpp

@@ -1,29 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_MSGPACK_TUPLE_HPP
-#define MSGPACK_MSGPACK_TUPLE_HPP
-
-#include "msgpack/cpp_config.hpp"
-
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_msgpack_tuple.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_msgpack_tuple.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#endif // MSGPACK_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/msgpack_tuple_fwd.hpp

@@ -1,29 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_MSGPACK_TUPLE_FWD_HPP
-#define MSGPACK_MSGPACK_TUPLE_FWD_HPP
-
-#include "msgpack/cpp_config.hpp"
-
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_msgpack_tuple_fwd.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_msgpack_tuple_fwd.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#endif // MSGPACK_MSGPACK_TUPLE_FWD_HPP

include/msgpack/adaptor/nil.hpp

@@ -1,68 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_NIL_HPP
-#define MSGPACK_TYPE_NIL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-struct nil { };
-
-}  // namespace type
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, type::nil&)
-{
-    if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); }
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::nil&)
-{
-    o.pack_nil();
-    return o;
-}
-
-inline void operator<< (msgpack::object& o, type::nil)
-{
-    o.type = msgpack::type::NIL;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, type::nil v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-template <>
-inline void msgpack::object::as<void>() const
-{
-    msgpack::type::nil v;
-    convert(v);
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_NIL_HPP

include/msgpack/adaptor/nil_fwd.hpp

@@ -1,51 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_NIL_FWD_HPP
-#define MSGPACK_TYPE_NIL_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-struct nil;
-
-}  // namespace type
-
-
-msgpack::object const& operator>> (msgpack::object const& o, type::nil&);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::nil&);
-
-void operator<< (msgpack::object& o, type::nil);
-
-void operator<< (msgpack::object::with_zone& o, type::nil v);
-
-template <>
-inline void msgpack::object::as<void>() const;
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_NIL_FWD_HPP

include/msgpack/adaptor/pair.hpp

@@ -1,63 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_PAIR_HPP
-#define MSGPACK_TYPE_PAIR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <utility>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T1, typename T2>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::pair<T1, T2>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size != 2) { throw msgpack::type_error(); }
-    o.via.array.ptr[0].convert(v.first);
-    o.via.array.ptr[1].convert(v.second);
-    return o;
-}
-
-template <typename Stream, typename T1, typename T2>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::pair<T1, T2>& v)
-{
-    o.pack_array(2);
-    o.pack(v.first);
-    o.pack(v.second);
-    return o;
-}
-
-template <typename T1, typename T2>
-inline void operator<< (msgpack::object::with_zone& o, const std::pair<T1, T2>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
-    o.via.array.ptr = p;
-    o.via.array.size = 2;
-    p[0] = msgpack::object(v.first, o.zone);
-    p[1] = msgpack::object(v.second, o.zone);
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_PAIR_HPP

include/msgpack/adaptor/pair_fwd.hpp

@@ -1,42 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_PAIR_FWD_HPP
-#define MSGPACK_TYPE_PAIR_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <utility>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T1, typename T2>
-msgpack::object const& operator>> (msgpack::object const& o, std::pair<T1, T2>& v);
-
-template <typename Stream, typename T1, typename T2>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::pair<T1, T2>& v);
-
-template <typename T1, typename T2>
-void operator<< (msgpack::object::with_zone& o, const std::pair<T1, T2>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_PAIR_FWD_HPP

include/msgpack/adaptor/raw.hpp

@@ -1,98 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_RAW_HPP
-#define MSGPACK_TYPE_RAW_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <string.h>
-#include <string>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-struct raw_ref {
-    raw_ref() : size(0), ptr(nullptr) {}
-    raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
-
-    uint32_t size;
-    const char* ptr;
-
-    std::string str() const { return std::string(ptr, size); }
-
-    bool operator== (const raw_ref& x) const
-    {
-        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
-    }
-
-    bool operator!= (const raw_ref& x) const
-    {
-        return !(*this != x);
-    }
-
-    bool operator< (const raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
-        else { return size < x.size; }
-    }
-
-    bool operator> (const raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
-        else { return size > x.size; }
-    }
-};
-
-}  // namespace type
-
-
-inline msgpack::object const& operator>> (msgpack::object const& o, msgpack::type::raw_ref& v)
-{
-    if(o.type != msgpack::type::BIN) { throw msgpack::type_error(); }
-    v.ptr  = o.via.bin.ptr;
-    v.size = o.via.bin.size;
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::type::raw_ref& v)
-{
-    o.pack_bin(v.size);
-    o.pack_bin_body(v.ptr, v.size);
-    return o;
-}
-
-inline void operator<< (msgpack::object& o, const msgpack::type::raw_ref& v)
-{
-    o.type = msgpack::type::BIN;
-    o.via.bin.ptr = v.ptr;
-    o.via.bin.size = v.size;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, const msgpack::type::raw_ref& v)
-    { static_cast<msgpack::object&>(o) << v; }
-
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_RAW_HPP

include/msgpack/adaptor/raw_fwd.hpp

@@ -1,50 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_RAW_FWD_HPP
-#define MSGPACK_TYPE_RAW_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <string.h>
-#include <string>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-namespace type {
-
-struct raw_ref;
-
-}  // namespace type
-
-
-msgpack::object const& operator>> (msgpack::object const& o, type::raw_ref& v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::raw_ref& v);
-
-void operator<< (msgpack::object& o, const type::raw_ref& v);
-
-void operator<< (msgpack::object::with_zone& o, const type::raw_ref& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_RAW_FWD_HPP

include/msgpack/adaptor/set.hpp

@@ -1,134 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_SET_HPP
-#define MSGPACK_TYPE_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <set>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::set<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::set<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::set<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::set<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::set<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::multiset<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::multiset<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::multiset<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::multiset<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::multiset<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_SET_HPP

include/msgpack/adaptor/set_fwd.hpp

@@ -1,52 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_SET_FWD_HPP
-#define MSGPACK_TYPE_SET_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#include <set>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::set<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::set<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::set<T>& v);
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, std::multiset<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::multiset<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const std::multiset<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_SET_FWD_HPP

include/msgpack/adaptor/string.hpp

@@ -1,78 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_STRING_HPP
-#define MSGPACK_TYPE_STRING_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <string>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-inline msgpack::object const& operator>> (msgpack::object const& o, std::string& v)
-{
-    switch (o.type) {
-    case msgpack::type::BIN:
-        v.assign(o.via.bin.ptr, o.via.bin.size);
-        break;
-    case msgpack::type::STR:
-        v.assign(o.via.str.ptr, o.via.str.size);
-        break;
-    default:
-        throw msgpack::type_error();
-        break;
-    }
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::string& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_str(size);
-    o.pack_str_body(v.data(), size);
-    return o;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, const std::string& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.type = msgpack::type::STR;
-    char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-    o.via.str.ptr = ptr;
-    o.via.str.size = size;
-    std::memcpy(ptr, v.data(), v.size());
-}
-
-inline void operator<< (msgpack::object& o, const std::string& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.type = msgpack::type::STR;
-    o.via.str.ptr = v.data();
-    o.via.str.size = size;
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_STRING_HPP

include/msgpack/adaptor/string_fwd.hpp

@@ -1,42 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_STRING_FWD_HPP
-#define MSGPACK_TYPE_STRING_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <string>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-msgpack::object const& operator>> (msgpack::object const& o, std::string& v);
-
-template <typename Stream>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::string& v);
-
-void operator<< (msgpack::object::with_zone& o, const std::string& v);
-
-void operator<< (msgpack::object& o, const std::string& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_STRING_FWD_HPP

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -1,164 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_MAP
-#include <unordered_map>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP
-
-#include <tr1/unordered_map>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    MSGPACK_STD_TR1::unordered_map<K, V> tmp;
-    for(; p != pend; ++p) {
-        K key;
-        p->key.convert(key);
-        p->val.convert(tmp[key]);
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename K, typename V>
-inline msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
-{
-    if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    msgpack::object_kv* p(o.via.map.ptr);
-    msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-    MSGPACK_STD_TR1::unordered_multimap<K, V> tmp;
-    for(; p != pend; ++p) {
-        std::pair<K, V> value;
-        p->key.convert(value.first);
-        p->val.convert(value.second);
-        tmp.insert(value);
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename K, typename V>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_map(size);
-    for(typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(it->first);
-        o.pack(it->second);
-    }
-    return o;
-}
-
-template <typename K, typename V>
-inline void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
-{
-    o.type = msgpack::type::MAP;
-    if(v.empty()) {
-        o.via.map.ptr  = nullptr;
-        o.via.map.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-        msgpack::object_kv* const pend = p + size;
-        o.via.map.ptr  = p;
-        o.via.map.size = size;
-        typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin());
-        do {
-            p->key = msgpack::object(it->first, o.zone);
-            p->val = msgpack::object(it->second, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP

include/msgpack/adaptor/tr1/unordered_map_fwd.hpp

@@ -1,75 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_MAP
-#include <unordered_map>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP
-
-#include <tr1/unordered_map>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V>& v);
-
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v);
-
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v);
-
-template <typename K, typename V>
-msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v);
-
-template <typename Stream, typename K, typename V>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v);
-
-template <typename K, typename V>
-void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -1,157 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_SET
-#include <unordered_set>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_SET
-
-#include <tr1/unordered_set>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    MSGPACK_STD_TR1::unordered_set<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    MSGPACK_STD_TR1::unordered_multiset<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
-    }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP

include/msgpack/adaptor/tr1/unordered_set_fwd.hpp

@@ -1,75 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_SET
-#include <unordered_set>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_SET
-
-#include <tr1/unordered_set>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T>& v);
-
-template <typename T>
-msgpack::object const& operator>> (msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T>& v);
-
-template <typename Stream, typename T>
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v);
-
-template <typename T>
-void operator<< (msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP

include/msgpack/adaptor/vector.hpp

@@ -1,87 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_VECTOR_HPP
-#define MSGPACK_TYPE_VECTOR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::vector<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    v.resize(o.via.array.size);
-    if(o.via.array.size > 0) {
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        T* it = &v[0];
-        do {
-            p->convert(*it);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::vector<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::vector<T>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-        o.pack(*it);
-    }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::vector<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::vector<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_VECTOR_HPP

include/msgpack/adaptor/vector_bool.hpp

@@ -1,80 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_VECTOR_BOOL_HPP
-#define MSGPACK_TYPE_VECTOR_BOOL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-inline msgpack::object const& operator>> (msgpack::object const& o, std::vector<bool>& v)
-{
-    if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if (o.via.array.size > 0) {
-        v.resize(o.via.array.size);
-        msgpack::object* p = o.via.array.ptr;
-        for (std::vector<bool>::iterator it = v.begin(), end = v.end();
-             it != end;
-             ++it) {
-            *it = p->as<bool>();
-            ++p;
-        }
-    }
-    return o;
-}
-
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::vector<bool>& v)
-{
-    o.pack_array(v.size());
-    for(std::vector<bool>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(static_cast<bool>(*it));
-    }
-    return o;
-}
-
-inline void operator<< (msgpack::object::with_zone& o, const std::vector<bool>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*v.size()));
-        msgpack::object* const pend = p + v.size();
-        o.via.array.ptr = p;
-        o.via.array.size = v.size();
-        std::vector<bool>::const_iterator it(v.begin());
-        do {
-            *p = object(static_cast<bool>(*it), o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
-    }
-}
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_VECTOR_BOOL_HPP

include/msgpack/adaptor/vector_bool_fwd.hpp

@@ -1,40 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_TYPE_VECTOR_BOOL_FWD_HPP
-#define MSGPACK_TYPE_VECTOR_BOOL_FWD_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-
-object const& operator>> (object const& o, std::vector<bool>& v);
-
-template <typename Stream>
-packer<Stream>& operator<< (packer<Stream>& o, const std::vector<bool>& v);
-
-void operator<< (object::with_zone& o, const std::vector<bool>& v);
-
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_VECTOR_BOOL_FWD_HPP