generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-04-19 15:47:15 +02:00
Code Issues Projects Releases Wiki Activity

Compare commits

base: generic-library:cpp-7.0.0
Branches Tags
generic-library:master
generic-library:cpp_master
generic-library:c_master
generic-library:cpp-6
generic-library:gh-pages
generic-library:cpp-1.4
generic-library:cpp-1.2
generic-library:cpp-0.5
generic-library:cpp-1.0
generic-library:poc/0.6
generic-library:cpp-7.0.0
generic-library:c-6.1.0
generic-library:c-6.0.2
generic-library:c-6.0.1
generic-library:cpp-6.1.1
generic-library:cpp-6.1.0
generic-library:cpp-6.0.0
generic-library:c-6.0.0
generic-library:c-5.0.0
generic-library:cpp-5.0.0
generic-library:cpp-4.1.3
generic-library:cpp-4.1.2
generic-library:cpp-4.1.1
generic-library:cpp-4.1.0
generic-library:cpp-4.0.3
generic-library:c-4.0.0
generic-library:cpp-4.0.2
generic-library:cpp-4.0.1
generic-library:cpp-4.0.0
generic-library:cpp-3.3.0
generic-library:cpp-3
generic-library:cpp-3.2.1
generic-library:cpp-3.2.0
generic-library:cpp-3.1.1
generic-library:cpp-3.1.0
generic-library:cpp-3.0.1
generic-library:cpp-3.0.0
generic-library:cpp-2.1.5
generic-library:cpp-2.1.4
generic-library:2.1.4
generic-library:cpp-2.1.3
generic-library:cpp-2.1.2
generic-library:cpp-2.1.1
generic-library:cpp-2.1.0
generic-library:cpp-2.0.0
generic-library:cpp-1.4.2
generic-library:cpp-1.4.1
generic-library:cpp-1.4.0
generic-library:cpp-1.3.0
generic-library:cpp-1.2.0
generic-library:cpp-1.1.0
generic-library:cpp-1.0.1
generic-library:cpp-1.0.0
generic-library:cpp-0.5.9
generic-library:cpp-0.5.8
generic-library:cpp-0.5.6
generic-library:cpp-0.5.5
generic-library:cpp-0.5.4
generic-library:cpp-0.5.3
generic-library:cpp-0.5.2
generic-library:cpp-0.5.1
generic-library:cpp-0.5.0
generic-library:cpp-0.4.3
generic-library:cpp-0.4.2
generic-library:cpp-0.4.1
generic-library:cpp-0.4.0
generic-library:cpp-0.3.8
generic-library:cpp-0.3.7
generic-library:cpp-0.3.6
generic-library:cpp-0.3.5
generic-library:cpp-0.3.4
generic-library:0.3.3
generic-library:0.3.2
generic-library:0.3.1
generic-library:0.3.0
..
compare: generic-library:master
Branches Tags
generic-library:cpp_master
generic-library:c_master
generic-library:cpp-6
generic-library:master
generic-library:gh-pages
generic-library:cpp-1.4
generic-library:cpp-1.2
generic-library:cpp-0.5
generic-library:cpp-1.0
generic-library:poc/0.6
generic-library:cpp-7.0.0
generic-library:c-6.1.0
generic-library:c-6.0.2
generic-library:c-6.0.1
generic-library:cpp-6.1.1
generic-library:cpp-6.1.0
generic-library:cpp-6.0.0
generic-library:c-6.0.0
generic-library:c-5.0.0
generic-library:cpp-5.0.0
generic-library:cpp-4.1.3
generic-library:cpp-4.1.2
generic-library:cpp-4.1.1
generic-library:cpp-4.1.0
generic-library:cpp-4.0.3
generic-library:c-4.0.0
generic-library:cpp-4.0.2
generic-library:cpp-4.0.1
generic-library:cpp-4.0.0
generic-library:cpp-3.3.0
generic-library:cpp-3
generic-library:cpp-3.2.1
generic-library:cpp-3.2.0
generic-library:cpp-3.1.1
generic-library:cpp-3.1.0
generic-library:cpp-3.0.1
generic-library:cpp-3.0.0
generic-library:cpp-2.1.5
generic-library:cpp-2.1.4
generic-library:2.1.4
generic-library:cpp-2.1.3
generic-library:cpp-2.1.2
generic-library:cpp-2.1.1
generic-library:cpp-2.1.0
generic-library:cpp-2.0.0
generic-library:cpp-1.4.2
generic-library:cpp-1.4.1
generic-library:cpp-1.4.0
generic-library:cpp-1.3.0
generic-library:cpp-1.2.0
generic-library:cpp-1.1.0
generic-library:cpp-1.0.1
generic-library:cpp-1.0.0
generic-library:cpp-0.5.9
generic-library:cpp-0.5.8
generic-library:cpp-0.5.6
generic-library:cpp-0.5.5
generic-library:cpp-0.5.4
generic-library:cpp-0.5.3
generic-library:cpp-0.5.2
generic-library:cpp-0.5.1
generic-library:cpp-0.5.0
generic-library:cpp-0.4.3
generic-library:cpp-0.4.2
generic-library:cpp-0.4.1
generic-library:cpp-0.4.0
generic-library:cpp-0.3.8
generic-library:cpp-0.3.7
generic-library:cpp-0.3.6
generic-library:cpp-0.3.5
generic-library:cpp-0.3.4
generic-library:0.3.3
generic-library:0.3.2
generic-library:0.3.1
generic-library:0.3.0

3 Commits
cpp-7.0.0 ... master

Author SHA1 Message Date
Takatoshi Kondo
b0d379a6f2
Update issue templates 2023-02-28 21:27:23 +09:00
Takatoshi Kondo
7d5324f294
Merge pull request #878 from ygj6/master 
remove files in master for separating C and C++ libraries
 2020-06-08 09:26:18 +09:00
yuangongji
61f8780d59 remove files in master for separating C and C++ libraries 2020-06-05 17:55:42 +08:00
850 changed files with 25 additions and 119160 deletions
Show Stats Expand all files Collapse all files

19
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@ -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.

72
.github/depends/boost.sh vendored
View File

@ -1,72 +0,0 @@
#!/bin/bash
usage()
{
cat <<EOL
-b - 32-bit or 64-bit library, maybe 32, 64 or both
-t - the toolset, maybe gcc, clang or both
-p - installation prefix
EOL
}
build_boost()
{
./b2 \
--toolset=$1 \
--prefix=$3/$2 \
--with-test \
--with-headers \
--with-chrono \
--with-context \
--with-filesystem \
--with-system \
--with-timer \
address-model=$2 \
install || exit 1
}
bit="64"
toolset="gcc"
prefix="$HOME/boost-prefix"
while getopts "b:t:p:" c; do
case "$c" in
b)
bit="$OPTARG"
[ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
;;
t)
toolset="$OPTARG"
[ "$toolset" != "gcc" ] && [ "$toolset" != "clang" ] && [ "$toolset" != "both" ] && usage && exit 1
;;
p)
prefix="$OPTARG"
;;
?*)
echo "invalid arguments." && exit 1
;;
esac
done
mkdir $prefix || exit 1
wget https://boostorg.jfrog.io/artifactory/main/release/1.85.0/source/boost_1_85_0.tar.bz2 || exit 1
tar xf boost_1_85_0.tar.bz2 || exit 1
cd boost_1_85_0
./bootstrap.sh || exit 1
build()
{
if [ "$bit" = "both" ]; then
build_boost $1 32 $prefix
build_boost $1 64 $prefix
else
build_boost $1 $bit $prefix
fi
}
if [ "$toolset" = "both" ]; then
build gcc
build clang
else
build $toolset
fi

51
.github/depends/zlib.sh vendored
View File

@ -1,51 +0,0 @@
#!/bin/bash
usage()
{
cat <<EOL
-b - 32-bit or 64-bit library, maybe 32 or 64
-p - installation prefix
EOL
}
bit="64"
prefix="$HOME/zlib-prefix"
while getopts "b:t:p:" c; do
case "$c" in
b)
bit="$OPTARG"
[ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
;;
p)
prefix="$OPTARG"
;;
?*)
echo "invalid arguments." && exit 1
;;
esac
done
mkdir $prefix || exit 1
wget https://zlib.net/zlib-1.3.1.tar.gz || exit 1
tar -xf zlib-1.3.1.tar.gz || exit 1
cd zlib-1.3.1
build()
{
cmake \
-D CMAKE_BUILD_TYPE=Release \
-D CMAKE_INSTALL_PREFIX=$2/$1 \
-D CMAKE_C_FLAGS="-m$1" \
-D CMAKE_SHARED_LINKER_FLAGS="-m$1" \
-B build$1 \
-S .
cmake --build build$1 --target install
}
if [ "$bit" = "both" ]; then
build 32 $prefix
build 64 $prefix
else
build $bit $prefix
fi

74
.github/workflows/coverage.yml vendored
View File

@ -1,74 +0,0 @@
name: coverage
on:
pull_request:
types: [opened, synchronize]
push:
branches:
- cpp_master
tags:
- '*'
jobs:
codecov:
timeout-minutes: 30
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v1
- name: Install build dependencies
run: |
sudo apt-get update
sudo apt-get install g++-10 cmake lcov -y
./ci/set_gcc_10.sh
- name: Cache boost
id: cache-boost
uses: actions/cache@v1
with:
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-1-85-0-2024-05-27
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b 64 -t gcc -p $HOME/boost-prefix
- name: Cache zlib
id: cache-zlib
uses: actions/cache@v1
with:
path: ~/zlib-prefix/
key: ${{ runner.os }}-zlib-64-1-2-11-2021-08-09
- name: Build zlib
if: steps.cache-zlib.outputs.cache-hit != 'true'
run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
- name: Compile tests
run: |
mkdir build
cmake \
-D MSGPACK_CXX20=ON \
-D MSGPACK_32BIT=OFF \
-D MSGPACK_CHAR_SIGN=signed \
-D MSGPACK_USE_X3_PARSE=ON \
-D MSGPACK_BUILD_EXAMPLES=ON \
-D MSGPACK_BUILD_TESTS=ON \
-D CMAKE_BUILD_TYPE=Debug \
-D MSGPACK_GEN_COVERAGE=ON \
-D MSGPACK_USE_STD_VARIANT_ADAPTOR=ON \
-D CMAKE_PREFIX_PATH="$HOME/zlib-prefix/64;$HOME/boost-prefix/64" \
-B build \
-S . || exit 1
cmake --build build --target all || exit 1
ctest --test-dir build || exit 1
- name: Upload coverage to Codecov
working-directory: build
run: |
# Create lcov report
lcov --capture --directory . --output-file coverage.info
lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter system-files
lcov --list coverage.info # debug info
# Uploading report to CodeCov
bash <(curl -s https://codecov.io/bash) -f coverage.info || echo "Codecov did not collect coverage reports"

244
.github/workflows/gha.yml vendored
View File

@ -1,244 +0,0 @@
name: CI
on:
pull_request:
types: [opened, synchronize]
push:
branches:
- cpp_master
tags:
- '*'
jobs:
macos:
name: ${{ format('macOS (pattern {0})', matrix.pattern) }}
runs-on: macos-latest
strategy:
fail-fast: false
matrix:
pattern: [0, 1, 2, 3, 4]
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Install Dependencies
run: |
brew update
brew install --force llvm
- name: Cache boost
id: cache-boost
uses: actions/cache@v3
with:
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-1-85-0-2024-05-27
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b 64 -t clang -p $HOME/boost-prefix
- name: Cache zlib
id: cache-zlib
uses: actions/cache@v3
with:
path: ~/zlib-prefix/
key: ${{ runner.os }}-zlib-1-2-13-2022-11-02
- name: Build zlib
if: steps.cache-zlib.outputs.cache-hit != 'true'
run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
- name: Build and test
shell: bash
run: |
# default configuration - overwrite its params later depending on matrix.pattern
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
export ARCH=64
export API_VERSION=3
export CHAR_SIGN="signed"
export X3_PARSE="OFF"
export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
case ${{ matrix.pattern }} in
0)
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
;;
1)
export API_VERSION=1
;;
2)
export API_VERSION=2
;;
3)
export X3_PARSE="ON"
;;
4)
export CHAR_SIGN="unsigned"
;;
esac
# build and test
export CXX="clang++"
CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh || exit 1
cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1 && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
linux:
name: ${{ format('Linux (pattern {0})', matrix.pattern) }}
runs-on: ubuntu-20.04
strategy:
fail-fast: false
matrix:
pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
steps:
- uses: actions/checkout@v3
- name: Install build dependencies
shell: bash
run: |
sudo apt-get update
sudo apt-get install g++-10 cmake valgrind -y
sudo apt-get install g++-10-multilib -y # for 32-bit compile
./ci/set_gcc_10.sh
- name: Cache boost
id: cache-boost
uses: actions/cache@v3
with:
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-1-85-0-2024-05-27
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b both -t gcc -p $HOME/boost-prefix
- name: Cache zlib
id: cache-zlib
uses: actions/cache@v3
with:
path: ~/zlib-prefix/
key: ${{ runner.os }}-zlib-1-2-13-2022-11-02
- name: Build zlib
if: steps.cache-zlib.outputs.cache-hit != 'true'
run: ./.github/depends/zlib.sh -b both -p $HOME/zlib-prefix
- name: Build and test
shell: bash
run: |
# default configuration - overwrite its params later depending on matrix.pattern
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
export ARCH=64
export API_VERSION=3
export CHAR_SIGN="signed"
export X3_PARSE="OFF"
export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
export ACTION="ci/build_cmake.sh"
case ${{ matrix.pattern }} in
0)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
;;
1)
export CXX="g++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
;;
2)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX14=ON"
;;
3)
export CXX="g++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX17=ON"
export MSGPACK_USE_STD_VARIANT_ADAPTOR="MSGPACK_USE_STD_VARIANT_ADAPTOR=ON"
;;
4)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
export NO_BOOST="-DMSGPACK_NO_BOOST"
;;
5)
export CXX="g++-10"
export ARCH=32
;;
6)
export CXX="clang++-10"
export API_VERSION=2
;;
7)
export CXX="g++-10"
export API_VERSION=1
;;
8)
export CXX="clang++-10"
export CHAR_SIGN="unsigned"
;;
9)
export CXX="g++-10"
export X3_PARSE="ON"
;;
10)
export CXX="clang++-10"
export ACTION="ci/build_regression.sh"
;;
11)
export CXX="g++-10"
export ARCH=32
export CHAR_SIGN="unsigned"
export X3_PARSE="ON"
;;
esac
# build and test
CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE} ${NO_BOOST}" ci/build_cmake.sh || exit 1
cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1 && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
windows:
name: ${{ format('Windows cxx{0}', matrix.cxx) }}
runs-on: windows-2019
strategy:
fail-fast: false
matrix:
# MSVC2019 only supports /std:c++14, /std:c++17 and /std:c++latest
cxx: [14, 17, 20]
pp_flag: ["/Zc:preprocessor-", "/Zc:preprocessor"]
steps:
- uses: actions/checkout@v3
- name: Cache vcpkg dependencies
id: cache-vcpkg
uses: actions/cache@v3
with:
path: C:/vcpkg/installed/x64-windows
key: ${{ runner.os }}-vcpkg-2021-08-09
- name: Install vcpkg dependencies
if: steps.cache-vcpkg.outputs.cache-hit != 'true'
shell: powershell
run: |
vcpkg update
vcpkg install zlib:x64-windows
vcpkg install boost-assert:x64-windows boost-numeric-conversion:x64-windows boost-variant:x64-windows boost-utility:x64-windows boost-fusion:x64-windows boost-optional:x64-windows boost-predef:x64-windows boost-preprocessor:x64-windows boost-timer:x64-windows boost-test:x64-windows
- name: Build and test
shell: powershell
run: |
$CPPVER="MSGPACK_CXX${{ matrix.cxx }}=ON"
md build
cmake `
-A x64 `
-G "Visual Studio 16 2019" `
-D CMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" `
-D MSGPACK_BUILD_TESTS=ON `
-D $CPPVER `
-D CMAKE_CXX_FLAGS="${{ matrix.pp_flag }} /D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING /D_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING /D_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING /W3 /WX" `
-B build `
-S .
if ($LastExitCode -ne 0) { exit $LastExitCode }
cmake --build build --config Release
if ($LastExitCode -ne 0) { exit $LastExitCode }
ctest -VV --test-dir build -C Release
if ($LastExitCode -ne 0) { exit $LastExitCode }

56
.gitignore vendored
View File

@ -1,56 +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
build
*-build
.cache
compile_commands.json

81
CHANGELOG.md
View File

@ -1,84 +1,3 @@
# 2024-11-02 version 7.0.0
* Refine build system (#1133)
* Refine CI (#1122)
* Refine documents (#1117)
## << breaking changes >>
* Revert double and fload packing behavior (#1144)
* If below decimal point is zero (e.g. 2.00),
* Before: pack as int format family `0x02`
* After : pack as float format family `0xcb 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00`
# 2024-04-02 version 6.1.1
* Fix compilation error when std::variant has the same types (#1112)
* Improve CI (#1090, #1110)
* Fix to avoid common function name's (has_as::check) ambiguity/conflict with other libraries' macros (#1085)
# 2023-07-08 version 6.1.0
* Remove dependency on boost in chrono.hpp (#1076)
* Add support for std::variant behavior (#1075)
* Fix msgpack::type::variant behavior to respect MessagePack format (#1071)
* Add rebind allocators (#1065)
# 2023-03-02 version 6.0.0
## << breaking changes >>
* Change CMake package name of C++ library to msgpack-cxx (#1054)
Unified all C++ package, library, cmake, tarball name become msgpack-cxx.
# 2023-01-10 version 5.0.0 for C++
* Fix config for new MSVC preprocessor (#1040)
## << breaking changes >>
* Change CMake package name of C++ library to msgpackc-cxx (#1045, #1048)
# 2022-11-02 version 4.1.3 for C++
* Fix compile error that direct inclusion of chrono with `MSGPACK_NO_BOOST` (#1038))
# 2022-09-07 version 4.1.2 for C++
* Fix noexcept on zone (#1030)
* Improve cmake support (#1028, #1032)
* Improve CI (#1023)
* Improve supporting platform (#1021)
* Refine double/float packing (#1018)
* Refine include files dependency (#1011)
# 2022-03-09 version 4.1.1 for C++
* Remove chrono support on `MSGPACK_NO_BOOST` to fix compile error.
* Improve build system (#1003)
# 2022-02-12 version 4.1.0 for C++
* Add experimental support for no boost dependency (#1001)
* For cmake, add `-DMSGPACK_USE_BOOST=OFF`. For C++ compiler add `-DMSGPACK_NO_BOOST`.
* Improve BIN console output (#995)
* Fix include notation (#991)
# 2021-10-23 version 4.0.3 for C++
* Remove Enabler2 template parameter from object adaptor (#987)
* Add MSGPACK_BUILD_DOCS cmake option (#983, #984)
# 2021-08-31 version 4.0.2 for C++
* Fix fuzzer interface function name (#972)
* Fix boost test link error and support both dynamin(default) and static link boost (#971)
# 2021-08-30 version 4.0.1 for C++
* Fix release tarball and its generation script (#967)
# 2021-08-29 version 4.0.0 for C++
* Improve zone alignment logic (#965)
* Fix v1 unpack logic for STR and BIN (#957, #951)
* Fix UB on memcmp with size 0 (#954)
* Fix `iovec` name conflict (#952)
* Add `std::array<std::byte>` `std::span<char>` `std::span<unsigned char>` `std::span<std::byte>` adaptors (#951)
* Improve documents (#918, #919, #951)
* Improve tests (#916)
* Introduce BOOST_ASSERT (#898)
* Improve build system (#897, #905, #924, #951)
* Improve Boost.Fusion support (#894)
* Check nullptr before call memcpy (#891)
* Refine and bugfix `std::chrono::time_point` adaptor (#888, #893)
* Improve CI (#884, #892, #895, #951, #955)
## << breaking changes >>
* Separate C++ part of the msgpack-c from C/C++ mixed msgpack-c (#876, #878)
* Require boost libraries. See README.md Dependency(#912)
# 2020-06-05 version 3.3.0
* Add json example for C (#870)
* Add both header and body packing functions for C (#870)

268
CMakeLists.txt
View File

@ -1,268 +0,0 @@
if(${CMAKE_VERSION} VERSION_GREATER "3.4")
CMAKE_MINIMUM_REQUIRED (VERSION 3.5)
else()
CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
(CMAKE_VERSION VERSION_EQUAL 3.1))
CMAKE_POLICY(SET CMP0054 NEW)
ENDIF ()
endif()
PROJECT (msgpack-cxx LANGUAGES CXX)
ADD_LIBRARY (msgpack-cxx INTERFACE)
FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.hpp 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})
LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
OPTION (MSGPACK_CXX11 "Using c++11 compiler" ON)
OPTION (MSGPACK_CXX14 "Using c++14 compiler" OFF)
OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
OPTION (MSGPACK_CXX20 "Using c++20 compiler" OFF)
OPTION (MSGPACK_32BIT "32bit compile" OFF)
OPTION (MSGPACK_USE_BOOST "Use Boost libraried" ON)
OPTION (MSGPACK_USE_X3_PARSE "Use Boost X3 parse" OFF)
OPTION (MSGPACK_BUILD_TESTS "Build tests" OFF)
OPTION (MSGPACK_BUILD_DOCS "Build Doxygen documentation" ON)
OPTION (MSGPACK_FUZZ_REGRESSION "Enable regression testing" OFF)
OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples" OFF)
OPTION (MSGPACK_GEN_COVERAGE "Generate coverage report" OFF)
OPTION (MSGPACK_USE_STATIC_BOOST "Statically link with boost libraries" OFF)
OPTION (MSGPACK_CHAR_SIGN "Char sign to use (signed or unsigned)")
OPTION (MSGPACK_USE_STD_VARIANT_ADAPTOR "Enable the adaptor for std::variant" OFF)
SET (CMAKE_CXX_STANDARD_REQUIRED ON)
IF (MSGPACK_USE_X3_PARSE)
IF (NOT (MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20))
MESSAGE (FATAL_ERROR "MSGPACK_USE_X3_PARSE requires MSGPACK_CXX14 or newer")
ENDIF ()
SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
ENDIF ()
IF (MSGPACK_CXX20)
SET (CMAKE_CXX_STANDARD 20)
ELSEIF (MSGPACK_CXX17)
SET (CMAKE_CXX_STANDARD 17)
ELSEIF (MSGPACK_CXX14)
SET (CMAKE_CXX_STANDARD 14)
ELSEIF (MSGPACK_CXX11)
SET (CMAKE_CXX_STANDARD 11)
ELSE ()
SET (CMAKE_CXX_STANDARD 98)
ENDIF ()
IF (MSGPACK_32BIT)
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
ENDIF ()
ENDIF ()
IF (MSGPACK_USE_BOOST)
IF ((CMAKE_VERSION VERSION_GREATER 3.30) OR
(CMAKE_VERSION VERSION_EQUAL 3.30))
CMAKE_POLICY(SET CMP0167 NEW)
ENDIF ()
SET (Boost_USE_MULTITHREADED ON)
IF (MSGPACK_USE_STATIC_BOOST)
MESSAGE (STATUS "Staticly linking with Boost")
SET (Boost_USE_STATIC_LIBS TRUE)
ELSE ()
MESSAGE (STATUS "Dynamically linking with Boost")
SET (Boost_USE_STATIC_LIBS FALSE)
ENDIF ()
FIND_PACKAGE (Boost REQUIRED)
ELSE ()
TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_NO_BOOST)
ENDIF ()
IF (MSGPACK_CHAR_SIGN)
TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -f${MSGPACK_CHAR_SIGN}-char)
ENDIF ()
IF (MSGPACK_DEFAULT_API_VERSION)
TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION})
ELSE ()
SET (MSGPACK_DEFAULT_API_VERSION 3)
TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=3)
ENDIF ()
IF (MSGPACK_USE_STD_VARIANT_ADAPTOR)
TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_USE_STD_VARIANT_ADAPTOR)
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.1)
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)
ENDIF ()
ENDIF ()
INCLUDE (Files.cmake)
TARGET_INCLUDE_DIRECTORIES (msgpack-cxx
INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
$<INSTALL_INTERFACE:include>
)
IF (MSGPACK_USE_BOOST)
TARGET_LINK_LIBRARIES (msgpack-cxx INTERFACE Boost::boost)
ENDIF ()
IF (MSGPACK_GEN_COVERAGE)
IF (NOT MSGPACK_BUILD_TESTS)
MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON")
ENDIF ()
STRING (TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_CMAKE_BUILD_TYPE)
IF (NOT "${UPPER_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
MESSAGE (FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
ENDIF ()
INCLUDE (CodeCoverage)
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS}")
SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
ENDIF ()
IF (MSGPACK_BUILD_TESTS)
IF (${CMAKE_CXX_STANDARD} EQUAL 98)
MESSAGE (FATAL_ERROR "Tests requires C++11 or newer")
ENDIF ()
IF ((CMAKE_VERSION VERSION_GREATER 3.27) OR
(CMAKE_VERSION VERSION_EQUAL 3.27))
CMAKE_POLICY(SET CMP0145 OLD)
ENDIF ()
IF (NOT MSGPACK_USE_BOOST)
MESSAGE(FATAL_ERROR "Test requires -DMSGPACK_USE_BOOST=ON")
ENDIF ()
ENABLE_TESTING ()
# MEMORYCHECK_COMMAND_OPTIONS needs to place prior to CTEST_MEMORYCHECK_COMMAND
SET (MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --show-leak-kinds=definite,possible --error-exitcode=1")
FIND_PROGRAM (CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
INCLUDE (Dart)
ADD_SUBDIRECTORY (test)
ENDIF ()
# enable regression testing
IF (MSGPACK_FUZZ_REGRESSION)
ENABLE_TESTING ()
ADD_SUBDIRECTORY (fuzz)
ENDIF ()
IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_ZONE_ALIGN=8)
ENDIF ()
IF (MSGPACK_BUILD_EXAMPLES)
ADD_SUBDIRECTORY (example)
ENDIF ()
# Doxygen
IF (MSGPACK_BUILD_DOCS)
FIND_PACKAGE (Doxygen)
IF (DOXYGEN_FOUND)
LIST (APPEND Doxyfile_cpp_CONTENT
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 "INPUT = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
)
IF (DOXYGEN_DOT_FOUND)
LIST (APPEND Doxyfile_cpp_CONTENT
COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
)
ENDIF ()
ADD_CUSTOM_TARGET (
doxygen
${Doxyfile_cpp_CONTENT}
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
)
ENDIF ()
ENDIF ()
include (GNUInstallDirs)
# Install library.
INSTALL (TARGETS msgpack-cxx
EXPORT msgpack-cxx-targets
COMPONENT msgpack-cxx
# This provides include directory in exported target
# relative to prefix in single directory we've put everything in.
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
)
# Install headers from source tree.
INSTALL (DIRECTORY include/
DESTINATION include
COMPONENT msgpack-cxx
)
INCLUDE (CMakePackageConfigHelpers)
IF (NOT (CMAKE_VERSION VERSION_LESS 3.14))
SET (extra_version_file_args ARCH_INDEPENDENT)
ENDIF ()
SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack-cxx")
# Configure the main package file from source tree.
CONFIGURE_PACKAGE_CONFIG_FILE (
msgpack-cxx-config.cmake.in
"${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
INSTALL_DESTINATION "${cmake_config_path}"
)
# Write package version file.
WRITE_BASIC_PACKAGE_VERSION_FILE (
msgpack-cxx-config-version.cmake
VERSION ${VERSION}
COMPATIBILITY SameMajorVersion
${extra_version_file_args}
)
# Install the generated package version file and the main package file.
INSTALL (FILES
"${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config-version.cmake"
DESTINATION "${cmake_config_path}"
COMPONENT msgpack-cxx
)
# This installs package in install tree for using installed targets.
INSTALL (
EXPORT msgpack-cxx-targets
FILE msgpack-cxx-targets.cmake
DESTINATION "${cmake_config_path}"
COMPONENT msgpack-cxx
)

1552
Doxyfile
View File

File diff suppressed because it is too large Load Diff

734
Files.cmake
View File

@ -1,734 +0,0 @@
SET (msgpack-cxx_HEADERS
include/msgpack.hpp
include/msgpack/adaptor/adaptor_base.hpp
include/msgpack/adaptor/adaptor_base_decl.hpp
include/msgpack/adaptor/array_ref.hpp
include/msgpack/adaptor/array_ref_decl.hpp
include/msgpack/adaptor/bool.hpp
include/msgpack/adaptor/boost/fusion.hpp
include/msgpack/adaptor/boost/msgpack_variant.hpp
include/msgpack/adaptor/boost/msgpack_variant_decl.hpp
include/msgpack/adaptor/boost/optional.hpp
include/msgpack/adaptor/boost/string_ref.hpp
include/msgpack/adaptor/boost/string_view.hpp
include/msgpack/adaptor/carray.hpp
include/msgpack/adaptor/char_ptr.hpp
include/msgpack/adaptor/check_container_size.hpp
include/msgpack/adaptor/check_container_size_decl.hpp
include/msgpack/adaptor/complex.hpp
include/msgpack/adaptor/cpp11/array.hpp
include/msgpack/adaptor/cpp11/array_char.hpp
include/msgpack/adaptor/cpp11/array_unsigned_char.hpp
include/msgpack/adaptor/cpp11/chrono.hpp
include/msgpack/adaptor/cpp11/forward_list.hpp
include/msgpack/adaptor/cpp11/reference_wrapper.hpp
include/msgpack/adaptor/cpp11/shared_ptr.hpp
include/msgpack/adaptor/cpp11/timespec.hpp
include/msgpack/adaptor/cpp11/tuple.hpp
include/msgpack/adaptor/cpp11/unique_ptr.hpp
include/msgpack/adaptor/cpp11/unordered_map.hpp
include/msgpack/adaptor/cpp11/unordered_set.hpp
include/msgpack/adaptor/cpp17/array_byte.hpp
include/msgpack/adaptor/cpp17/byte.hpp
include/msgpack/adaptor/cpp17/carray_byte.hpp
include/msgpack/adaptor/cpp17/optional.hpp
include/msgpack/adaptor/cpp17/string_view.hpp
include/msgpack/adaptor/cpp17/variant.hpp
include/msgpack/adaptor/cpp17/vector_byte.hpp
include/msgpack/adaptor/cpp20/span.hpp
include/msgpack/adaptor/define.hpp
include/msgpack/adaptor/define_decl.hpp
include/msgpack/adaptor/deque.hpp
include/msgpack/adaptor/ext.hpp
include/msgpack/adaptor/ext_decl.hpp
include/msgpack/adaptor/fixint.hpp
include/msgpack/adaptor/fixint_decl.hpp
include/msgpack/adaptor/float.hpp
include/msgpack/adaptor/int.hpp
include/msgpack/adaptor/int_decl.hpp
include/msgpack/adaptor/list.hpp
include/msgpack/adaptor/map.hpp
include/msgpack/adaptor/map_decl.hpp
include/msgpack/adaptor/msgpack_tuple.hpp
include/msgpack/adaptor/msgpack_tuple_decl.hpp
include/msgpack/adaptor/nil.hpp
include/msgpack/adaptor/nil_decl.hpp
include/msgpack/adaptor/pair.hpp
include/msgpack/adaptor/raw.hpp
include/msgpack/adaptor/raw_decl.hpp
include/msgpack/adaptor/set.hpp
include/msgpack/adaptor/size_equal_only.hpp
include/msgpack/adaptor/size_equal_only_decl.hpp
include/msgpack/adaptor/string.hpp
include/msgpack/adaptor/tr1/unordered_map.hpp
include/msgpack/adaptor/tr1/unordered_set.hpp
include/msgpack/adaptor/v4raw.hpp
include/msgpack/adaptor/v4raw_decl.hpp
include/msgpack/adaptor/vector.hpp
include/msgpack/adaptor/vector_bool.hpp
include/msgpack/adaptor/vector_char.hpp
include/msgpack/adaptor/vector_unsigned_char.hpp
include/msgpack/adaptor/wstring.hpp
include/msgpack/assert.hpp
include/msgpack/cpp_config.hpp
include/msgpack/cpp_config_decl.hpp
include/msgpack/cpp_version.hpp
include/msgpack/create_object_visitor.hpp
include/msgpack/create_object_visitor_decl.hpp
include/msgpack/fbuffer.hpp
include/msgpack/fbuffer_decl.hpp
include/msgpack/gcc_atomic.hpp
include/msgpack/iterator.hpp
include/msgpack/iterator_decl.hpp
include/msgpack/meta.hpp
include/msgpack/meta_decl.hpp
include/msgpack/null_visitor.hpp
include/msgpack/null_visitor_decl.hpp
include/msgpack/object.hpp
include/msgpack/object_decl.hpp
include/msgpack/object_fwd.hpp
include/msgpack/object_fwd_decl.hpp
include/msgpack/pack.hpp
include/msgpack/pack_decl.hpp
include/msgpack/parse.hpp
include/msgpack/parse_decl.hpp
include/msgpack/parse_return.hpp
include/msgpack/predef.h
include/msgpack/predef/architecture.h
include/msgpack/predef/architecture/alpha.h
include/msgpack/predef/architecture/arm.h
include/msgpack/predef/architecture/blackfin.h
include/msgpack/predef/architecture/convex.h
include/msgpack/predef/architecture/ia64.h
include/msgpack/predef/architecture/m68k.h
include/msgpack/predef/architecture/mips.h
include/msgpack/predef/architecture/parisc.h
include/msgpack/predef/architecture/ppc.h
include/msgpack/predef/architecture/ptx.h
include/msgpack/predef/architecture/pyramid.h
include/msgpack/predef/architecture/rs6k.h
include/msgpack/predef/architecture/sparc.h
include/msgpack/predef/architecture/superh.h
include/msgpack/predef/architecture/sys370.h
include/msgpack/predef/architecture/sys390.h
include/msgpack/predef/architecture/x86.h
include/msgpack/predef/architecture/x86/32.h
include/msgpack/predef/architecture/x86/64.h
include/msgpack/predef/architecture/z.h
include/msgpack/predef/compiler.h
include/msgpack/predef/compiler/borland.h
include/msgpack/predef/compiler/clang.h
include/msgpack/predef/compiler/comeau.h
include/msgpack/predef/compiler/compaq.h
include/msgpack/predef/compiler/diab.h
include/msgpack/predef/compiler/digitalmars.h
include/msgpack/predef/compiler/dignus.h
include/msgpack/predef/compiler/edg.h
include/msgpack/predef/compiler/ekopath.h
include/msgpack/predef/compiler/gcc.h
include/msgpack/predef/compiler/gcc_xml.h
include/msgpack/predef/compiler/greenhills.h
include/msgpack/predef/compiler/hp_acc.h
include/msgpack/predef/compiler/iar.h
include/msgpack/predef/compiler/ibm.h
include/msgpack/predef/compiler/intel.h
include/msgpack/predef/compiler/kai.h
include/msgpack/predef/compiler/llvm.h
include/msgpack/predef/compiler/metaware.h
include/msgpack/predef/compiler/metrowerks.h
include/msgpack/predef/compiler/microtec.h
include/msgpack/predef/compiler/mpw.h
include/msgpack/predef/compiler/nvcc.h
include/msgpack/predef/compiler/palm.h
include/msgpack/predef/compiler/pgi.h
include/msgpack/predef/compiler/sgi_mipspro.h
include/msgpack/predef/compiler/sunpro.h
include/msgpack/predef/compiler/tendra.h
include/msgpack/predef/compiler/visualc.h
include/msgpack/predef/compiler/watcom.h
include/msgpack/predef/detail/_cassert.h
include/msgpack/predef/detail/_exception.h
include/msgpack/predef/detail/comp_detected.h
include/msgpack/predef/detail/endian_compat.h
include/msgpack/predef/detail/os_detected.h
include/msgpack/predef/detail/platform_detected.h
include/msgpack/predef/detail/test.h
include/msgpack/predef/detail/test_def.h
include/msgpack/predef/hardware.h
include/msgpack/predef/hardware/simd.h
include/msgpack/predef/hardware/simd/arm.h
include/msgpack/predef/hardware/simd/arm/versions.h
include/msgpack/predef/hardware/simd/ppc.h
include/msgpack/predef/hardware/simd/ppc/versions.h
include/msgpack/predef/hardware/simd/x86.h
include/msgpack/predef/hardware/simd/x86/versions.h
include/msgpack/predef/hardware/simd/x86_amd.h
include/msgpack/predef/hardware/simd/x86_amd/versions.h
include/msgpack/predef/language.h
include/msgpack/predef/language/cuda.h
include/msgpack/predef/language/objc.h
include/msgpack/predef/language/stdc.h
include/msgpack/predef/language/stdcpp.h
include/msgpack/predef/library.h
include/msgpack/predef/library/c.h
include/msgpack/predef/library/c/_prefix.h
include/msgpack/predef/library/c/cloudabi.h
include/msgpack/predef/library/c/gnu.h
include/msgpack/predef/library/c/uc.h
include/msgpack/predef/library/c/vms.h
include/msgpack/predef/library/c/zos.h
include/msgpack/predef/library/std.h
include/msgpack/predef/library/std/_prefix.h
include/msgpack/predef/library/std/cxx.h
include/msgpack/predef/library/std/dinkumware.h
include/msgpack/predef/library/std/libcomo.h
include/msgpack/predef/library/std/modena.h
include/msgpack/predef/library/std/msl.h
include/msgpack/predef/library/std/roguewave.h
include/msgpack/predef/library/std/sgi.h
include/msgpack/predef/library/std/stdcpp3.h
include/msgpack/predef/library/std/stlport.h
include/msgpack/predef/library/std/vacpp.h
include/msgpack/predef/make.h
include/msgpack/predef/os.h
include/msgpack/predef/os/aix.h
include/msgpack/predef/os/amigaos.h
include/msgpack/predef/os/android.h
include/msgpack/predef/os/beos.h
include/msgpack/predef/os/bsd.h
include/msgpack/predef/os/bsd/bsdi.h
include/msgpack/predef/os/bsd/dragonfly.h
include/msgpack/predef/os/bsd/free.h
include/msgpack/predef/os/bsd/net.h
include/msgpack/predef/os/bsd/open.h
include/msgpack/predef/os/cygwin.h
include/msgpack/predef/os/haiku.h
include/msgpack/predef/os/hpux.h
include/msgpack/predef/os/ios.h
include/msgpack/predef/os/irix.h
include/msgpack/predef/os/linux.h
include/msgpack/predef/os/macos.h
include/msgpack/predef/os/os400.h
include/msgpack/predef/os/qnxnto.h
include/msgpack/predef/os/solaris.h
include/msgpack/predef/os/unix.h
include/msgpack/predef/os/vms.h
include/msgpack/predef/os/windows.h
include/msgpack/predef/other.h
include/msgpack/predef/other/endian.h
include/msgpack/predef/other/workaround.h
include/msgpack/predef/platform.h
include/msgpack/predef/platform/cloudabi.h
include/msgpack/predef/platform/ios.h
include/msgpack/predef/platform/mingw.h
include/msgpack/predef/platform/mingw32.h
include/msgpack/predef/platform/mingw64.h
include/msgpack/predef/platform/windows_desktop.h
include/msgpack/predef/platform/windows_phone.h
include/msgpack/predef/platform/windows_runtime.h
include/msgpack/predef/platform/windows_server.h
include/msgpack/predef/platform/windows_store.h
include/msgpack/predef/platform/windows_system.h
include/msgpack/predef/platform/windows_uwp.h
include/msgpack/predef/version.h
include/msgpack/predef/version_number.h
include/msgpack/preprocessor.hpp
include/msgpack/preprocessor/arithmetic.hpp
include/msgpack/preprocessor/arithmetic/add.hpp
include/msgpack/preprocessor/arithmetic/dec.hpp
include/msgpack/preprocessor/arithmetic/detail/div_base.hpp
include/msgpack/preprocessor/arithmetic/div.hpp
include/msgpack/preprocessor/arithmetic/inc.hpp
include/msgpack/preprocessor/arithmetic/mod.hpp
include/msgpack/preprocessor/arithmetic/mul.hpp
include/msgpack/preprocessor/arithmetic/sub.hpp
include/msgpack/preprocessor/array.hpp
include/msgpack/preprocessor/array/data.hpp
include/msgpack/preprocessor/array/detail/get_data.hpp
include/msgpack/preprocessor/array/elem.hpp
include/msgpack/preprocessor/array/enum.hpp
include/msgpack/preprocessor/array/insert.hpp
include/msgpack/preprocessor/array/pop_back.hpp
include/msgpack/preprocessor/array/pop_front.hpp
include/msgpack/preprocessor/array/push_back.hpp
include/msgpack/preprocessor/array/push_front.hpp
include/msgpack/preprocessor/array/remove.hpp
include/msgpack/preprocessor/array/replace.hpp
include/msgpack/preprocessor/array/reverse.hpp
include/msgpack/preprocessor/array/size.hpp
include/msgpack/preprocessor/array/to_list.hpp
include/msgpack/preprocessor/array/to_seq.hpp
include/msgpack/preprocessor/array/to_tuple.hpp
include/msgpack/preprocessor/assert_msg.hpp
include/msgpack/preprocessor/cat.hpp
include/msgpack/preprocessor/comma.hpp
include/msgpack/preprocessor/comma_if.hpp
include/msgpack/preprocessor/comparison.hpp
include/msgpack/preprocessor/comparison/equal.hpp
include/msgpack/preprocessor/comparison/greater.hpp
include/msgpack/preprocessor/comparison/greater_equal.hpp
include/msgpack/preprocessor/comparison/less.hpp
include/msgpack/preprocessor/comparison/less_equal.hpp
include/msgpack/preprocessor/comparison/not_equal.hpp
include/msgpack/preprocessor/config/config.hpp
include/msgpack/preprocessor/config/limits.hpp
include/msgpack/preprocessor/control.hpp
include/msgpack/preprocessor/control/deduce_d.hpp
include/msgpack/preprocessor/control/detail/dmc/while.hpp
include/msgpack/preprocessor/control/detail/edg/while.hpp
include/msgpack/preprocessor/control/detail/msvc/while.hpp
include/msgpack/preprocessor/control/detail/while.hpp
include/msgpack/preprocessor/control/expr_if.hpp
include/msgpack/preprocessor/control/expr_iif.hpp
include/msgpack/preprocessor/control/if.hpp
include/msgpack/preprocessor/control/iif.hpp
include/msgpack/preprocessor/control/while.hpp
include/msgpack/preprocessor/debug.hpp
include/msgpack/preprocessor/debug/assert.hpp
include/msgpack/preprocessor/debug/error.hpp
include/msgpack/preprocessor/debug/line.hpp
include/msgpack/preprocessor/dec.hpp
include/msgpack/preprocessor/detail/auto_rec.hpp
include/msgpack/preprocessor/detail/check.hpp
include/msgpack/preprocessor/detail/dmc/auto_rec.hpp
include/msgpack/preprocessor/detail/is_binary.hpp
include/msgpack/preprocessor/detail/is_nullary.hpp
include/msgpack/preprocessor/detail/is_unary.hpp
include/msgpack/preprocessor/detail/null.hpp
include/msgpack/preprocessor/detail/split.hpp
include/msgpack/preprocessor/empty.hpp
include/msgpack/preprocessor/enum.hpp
include/msgpack/preprocessor/enum_params.hpp
include/msgpack/preprocessor/enum_params_with_a_default.hpp
include/msgpack/preprocessor/enum_params_with_defaults.hpp
include/msgpack/preprocessor/enum_shifted.hpp
include/msgpack/preprocessor/enum_shifted_params.hpp
include/msgpack/preprocessor/expand.hpp
include/msgpack/preprocessor/expr_if.hpp
include/msgpack/preprocessor/facilities.hpp
include/msgpack/preprocessor/facilities/apply.hpp
include/msgpack/preprocessor/facilities/detail/is_empty.hpp
include/msgpack/preprocessor/facilities/empty.hpp
include/msgpack/preprocessor/facilities/expand.hpp
include/msgpack/preprocessor/facilities/identity.hpp
include/msgpack/preprocessor/facilities/intercept.hpp
include/msgpack/preprocessor/facilities/is_1.hpp
include/msgpack/preprocessor/facilities/is_empty.hpp
include/msgpack/preprocessor/facilities/is_empty_or_1.hpp
include/msgpack/preprocessor/facilities/is_empty_variadic.hpp
include/msgpack/preprocessor/facilities/overload.hpp
include/msgpack/preprocessor/for.hpp
include/msgpack/preprocessor/identity.hpp
include/msgpack/preprocessor/if.hpp
include/msgpack/preprocessor/inc.hpp
include/msgpack/preprocessor/iterate.hpp
include/msgpack/preprocessor/iteration.hpp
include/msgpack/preprocessor/iteration/detail/bounds/lower1.hpp
include/msgpack/preprocessor/iteration/detail/bounds/lower2.hpp
include/msgpack/preprocessor/iteration/detail/bounds/lower3.hpp
include/msgpack/preprocessor/iteration/detail/bounds/lower4.hpp
include/msgpack/preprocessor/iteration/detail/bounds/lower5.hpp
include/msgpack/preprocessor/iteration/detail/bounds/upper1.hpp
include/msgpack/preprocessor/iteration/detail/bounds/upper2.hpp
include/msgpack/preprocessor/iteration/detail/bounds/upper3.hpp
include/msgpack/preprocessor/iteration/detail/bounds/upper4.hpp
include/msgpack/preprocessor/iteration/detail/bounds/upper5.hpp
include/msgpack/preprocessor/iteration/detail/finish.hpp
include/msgpack/preprocessor/iteration/detail/iter/forward1.hpp
include/msgpack/preprocessor/iteration/detail/iter/forward2.hpp
include/msgpack/preprocessor/iteration/detail/iter/forward3.hpp
include/msgpack/preprocessor/iteration/detail/iter/forward4.hpp
include/msgpack/preprocessor/iteration/detail/iter/forward5.hpp
include/msgpack/preprocessor/iteration/detail/iter/reverse1.hpp
include/msgpack/preprocessor/iteration/detail/iter/reverse2.hpp
include/msgpack/preprocessor/iteration/detail/iter/reverse3.hpp
include/msgpack/preprocessor/iteration/detail/iter/reverse4.hpp
include/msgpack/preprocessor/iteration/detail/iter/reverse5.hpp
include/msgpack/preprocessor/iteration/detail/local.hpp
include/msgpack/preprocessor/iteration/detail/rlocal.hpp
include/msgpack/preprocessor/iteration/detail/self.hpp
include/msgpack/preprocessor/iteration/detail/start.hpp
include/msgpack/preprocessor/iteration/iterate.hpp
include/msgpack/preprocessor/iteration/local.hpp
include/msgpack/preprocessor/iteration/self.hpp
include/msgpack/preprocessor/library.hpp
include/msgpack/preprocessor/limits.hpp
include/msgpack/preprocessor/list.hpp
include/msgpack/preprocessor/list/adt.hpp
include/msgpack/preprocessor/list/append.hpp
include/msgpack/preprocessor/list/at.hpp
include/msgpack/preprocessor/list/cat.hpp
include/msgpack/preprocessor/list/detail/dmc/fold_left.hpp
include/msgpack/preprocessor/list/detail/edg/fold_left.hpp
include/msgpack/preprocessor/list/detail/edg/fold_right.hpp
include/msgpack/preprocessor/list/detail/fold_left.hpp
include/msgpack/preprocessor/list/detail/fold_right.hpp
include/msgpack/preprocessor/list/enum.hpp
include/msgpack/preprocessor/list/filter.hpp
include/msgpack/preprocessor/list/first_n.hpp
include/msgpack/preprocessor/list/fold_left.hpp
include/msgpack/preprocessor/list/fold_right.hpp
include/msgpack/preprocessor/list/for_each.hpp
include/msgpack/preprocessor/list/for_each_i.hpp
include/msgpack/preprocessor/list/for_each_product.hpp
include/msgpack/preprocessor/list/rest_n.hpp
include/msgpack/preprocessor/list/reverse.hpp
include/msgpack/preprocessor/list/size.hpp
include/msgpack/preprocessor/list/to_array.hpp
include/msgpack/preprocessor/list/to_seq.hpp
include/msgpack/preprocessor/list/to_tuple.hpp
include/msgpack/preprocessor/list/transform.hpp
include/msgpack/preprocessor/logical.hpp
include/msgpack/preprocessor/logical/and.hpp
include/msgpack/preprocessor/logical/bitand.hpp
include/msgpack/preprocessor/logical/bitnor.hpp
include/msgpack/preprocessor/logical/bitor.hpp
include/msgpack/preprocessor/logical/bitxor.hpp
include/msgpack/preprocessor/logical/bool.hpp
include/msgpack/preprocessor/logical/compl.hpp
include/msgpack/preprocessor/logical/nor.hpp
include/msgpack/preprocessor/logical/not.hpp
include/msgpack/preprocessor/logical/or.hpp
include/msgpack/preprocessor/logical/xor.hpp
include/msgpack/preprocessor/max.hpp
include/msgpack/preprocessor/min.hpp
include/msgpack/preprocessor/punctuation.hpp
include/msgpack/preprocessor/punctuation/comma.hpp
include/msgpack/preprocessor/punctuation/comma_if.hpp
include/msgpack/preprocessor/punctuation/detail/is_begin_parens.hpp
include/msgpack/preprocessor/punctuation/is_begin_parens.hpp
include/msgpack/preprocessor/punctuation/paren.hpp
include/msgpack/preprocessor/punctuation/paren_if.hpp
include/msgpack/preprocessor/punctuation/remove_parens.hpp
include/msgpack/preprocessor/repeat.hpp
include/msgpack/preprocessor/repeat_2nd.hpp
include/msgpack/preprocessor/repeat_3rd.hpp
include/msgpack/preprocessor/repeat_from_to.hpp
include/msgpack/preprocessor/repeat_from_to_2nd.hpp
include/msgpack/preprocessor/repeat_from_to_3rd.hpp
include/msgpack/preprocessor/repetition.hpp
include/msgpack/preprocessor/repetition/deduce_r.hpp
include/msgpack/preprocessor/repetition/deduce_z.hpp
include/msgpack/preprocessor/repetition/detail/dmc/for.hpp
include/msgpack/preprocessor/repetition/detail/edg/for.hpp
include/msgpack/preprocessor/repetition/detail/for.hpp
include/msgpack/preprocessor/repetition/detail/msvc/for.hpp
include/msgpack/preprocessor/repetition/enum.hpp
include/msgpack/preprocessor/repetition/enum_binary_params.hpp
include/msgpack/preprocessor/repetition/enum_params.hpp
include/msgpack/preprocessor/repetition/enum_params_with_a_default.hpp
include/msgpack/preprocessor/repetition/enum_params_with_defaults.hpp
include/msgpack/preprocessor/repetition/enum_shifted.hpp
include/msgpack/preprocessor/repetition/enum_shifted_binary_params.hpp
include/msgpack/preprocessor/repetition/enum_shifted_params.hpp
include/msgpack/preprocessor/repetition/enum_trailing.hpp
include/msgpack/preprocessor/repetition/enum_trailing_binary_params.hpp
include/msgpack/preprocessor/repetition/enum_trailing_params.hpp
include/msgpack/preprocessor/repetition/for.hpp
include/msgpack/preprocessor/repetition/repeat.hpp
include/msgpack/preprocessor/repetition/repeat_from_to.hpp
include/msgpack/preprocessor/selection.hpp
include/msgpack/preprocessor/selection/max.hpp
include/msgpack/preprocessor/selection/min.hpp
include/msgpack/preprocessor/seq.hpp
include/msgpack/preprocessor/seq/cat.hpp
include/msgpack/preprocessor/seq/detail/binary_transform.hpp
include/msgpack/preprocessor/seq/detail/is_empty.hpp
include/msgpack/preprocessor/seq/detail/split.hpp
include/msgpack/preprocessor/seq/detail/to_list_msvc.hpp
include/msgpack/preprocessor/seq/elem.hpp
include/msgpack/preprocessor/seq/enum.hpp
include/msgpack/preprocessor/seq/filter.hpp
include/msgpack/preprocessor/seq/first_n.hpp
include/msgpack/preprocessor/seq/fold_left.hpp
include/msgpack/preprocessor/seq/fold_right.hpp
include/msgpack/preprocessor/seq/for_each.hpp
include/msgpack/preprocessor/seq/for_each_i.hpp
include/msgpack/preprocessor/seq/for_each_product.hpp
include/msgpack/preprocessor/seq/insert.hpp
include/msgpack/preprocessor/seq/pop_back.hpp
include/msgpack/preprocessor/seq/pop_front.hpp
include/msgpack/preprocessor/seq/push_back.hpp
include/msgpack/preprocessor/seq/push_front.hpp
include/msgpack/preprocessor/seq/remove.hpp
include/msgpack/preprocessor/seq/replace.hpp
include/msgpack/preprocessor/seq/rest_n.hpp
include/msgpack/preprocessor/seq/reverse.hpp
include/msgpack/preprocessor/seq/seq.hpp
include/msgpack/preprocessor/seq/size.hpp
include/msgpack/preprocessor/seq/subseq.hpp
include/msgpack/preprocessor/seq/to_array.hpp
include/msgpack/preprocessor/seq/to_list.hpp
include/msgpack/preprocessor/seq/to_tuple.hpp
include/msgpack/preprocessor/seq/transform.hpp
include/msgpack/preprocessor/seq/variadic_seq_to_seq.hpp
include/msgpack/preprocessor/slot.hpp
include/msgpack/preprocessor/slot/counter.hpp
include/msgpack/preprocessor/slot/detail/counter.hpp
include/msgpack/preprocessor/slot/detail/def.hpp
include/msgpack/preprocessor/slot/detail/shared.hpp
include/msgpack/preprocessor/slot/detail/slot1.hpp
include/msgpack/preprocessor/slot/detail/slot2.hpp
include/msgpack/preprocessor/slot/detail/slot3.hpp
include/msgpack/preprocessor/slot/detail/slot4.hpp
include/msgpack/preprocessor/slot/detail/slot5.hpp
include/msgpack/preprocessor/slot/slot.hpp
include/msgpack/preprocessor/stringize.hpp
include/msgpack/preprocessor/tuple.hpp
include/msgpack/preprocessor/tuple/detail/is_single_return.hpp
include/msgpack/preprocessor/tuple/eat.hpp
include/msgpack/preprocessor/tuple/elem.hpp
include/msgpack/preprocessor/tuple/enum.hpp
include/msgpack/preprocessor/tuple/insert.hpp
include/msgpack/preprocessor/tuple/pop_back.hpp
include/msgpack/preprocessor/tuple/pop_front.hpp
include/msgpack/preprocessor/tuple/push_back.hpp
include/msgpack/preprocessor/tuple/push_front.hpp
include/msgpack/preprocessor/tuple/rem.hpp
include/msgpack/preprocessor/tuple/remove.hpp
include/msgpack/preprocessor/tuple/replace.hpp
include/msgpack/preprocessor/tuple/reverse.hpp
include/msgpack/preprocessor/tuple/size.hpp
include/msgpack/preprocessor/tuple/to_array.hpp
include/msgpack/preprocessor/tuple/to_list.hpp
include/msgpack/preprocessor/tuple/to_seq.hpp
include/msgpack/preprocessor/variadic.hpp
include/msgpack/preprocessor/variadic/detail/is_single_return.hpp
include/msgpack/preprocessor/variadic/elem.hpp
include/msgpack/preprocessor/variadic/size.hpp
include/msgpack/preprocessor/variadic/to_array.hpp
include/msgpack/preprocessor/variadic/to_list.hpp
include/msgpack/preprocessor/variadic/to_seq.hpp
include/msgpack/preprocessor/variadic/to_tuple.hpp
include/msgpack/preprocessor/while.hpp
include/msgpack/preprocessor/wstringize.hpp
include/msgpack/sbuffer.hpp
include/msgpack/sbuffer_decl.hpp
include/msgpack/sysdep.hpp
include/msgpack/type.hpp
include/msgpack/unpack.hpp
include/msgpack/unpack_decl.hpp
include/msgpack/unpack_define.hpp
include/msgpack/unpack_exception.hpp
include/msgpack/v1/adaptor/adaptor_base.hpp
include/msgpack/v1/adaptor/adaptor_base_decl.hpp
include/msgpack/v1/adaptor/array_ref.hpp
include/msgpack/v1/adaptor/array_ref_decl.hpp
include/msgpack/v1/adaptor/bool.hpp
include/msgpack/v1/adaptor/boost/fusion.hpp
include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp
include/msgpack/v1/adaptor/boost/optional.hpp
include/msgpack/v1/adaptor/boost/string_ref.hpp
include/msgpack/v1/adaptor/boost/string_view.hpp
include/msgpack/v1/adaptor/carray.hpp
include/msgpack/v1/adaptor/char_ptr.hpp
include/msgpack/v1/adaptor/check_container_size.hpp
include/msgpack/v1/adaptor/check_container_size_decl.hpp
include/msgpack/v1/adaptor/complex.hpp
include/msgpack/v1/adaptor/cpp11/array.hpp
include/msgpack/v1/adaptor/cpp11/array_char.hpp
include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp
include/msgpack/v1/adaptor/cpp11/chrono.hpp
include/msgpack/v1/adaptor/cpp11/forward_list.hpp
include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp
include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp
include/msgpack/v1/adaptor/cpp11/timespec.hpp
include/msgpack/v1/adaptor/cpp11/tuple.hpp
include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
include/msgpack/v1/adaptor/cpp11/unordered_set.hpp
include/msgpack/v1/adaptor/cpp17/array_byte.hpp
include/msgpack/v1/adaptor/cpp17/byte.hpp
include/msgpack/v1/adaptor/cpp17/carray_byte.hpp
include/msgpack/v1/adaptor/cpp17/optional.hpp
include/msgpack/v1/adaptor/cpp17/string_view.hpp
include/msgpack/v1/adaptor/cpp17/variant.hpp
include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
include/msgpack/v1/adaptor/cpp20/span.hpp
include/msgpack/v1/adaptor/define.hpp
include/msgpack/v1/adaptor/define_decl.hpp
include/msgpack/v1/adaptor/deque.hpp
include/msgpack/v1/adaptor/detail/cpp03_define_array.hpp
include/msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp
include/msgpack/v1/adaptor/detail/cpp03_define_map.hpp
include/msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp
include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple.hpp
include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp
include/msgpack/v1/adaptor/detail/cpp11_define_array.hpp
include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp
include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp
include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp
include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp
include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
include/msgpack/v1/adaptor/ext.hpp
include/msgpack/v1/adaptor/ext_decl.hpp
include/msgpack/v1/adaptor/fixint.hpp
include/msgpack/v1/adaptor/fixint_decl.hpp
include/msgpack/v1/adaptor/float.hpp
include/msgpack/v1/adaptor/int.hpp
include/msgpack/v1/adaptor/int_decl.hpp
include/msgpack/v1/adaptor/list.hpp
include/msgpack/v1/adaptor/map.hpp
include/msgpack/v1/adaptor/map_decl.hpp
include/msgpack/v1/adaptor/msgpack_tuple.hpp
include/msgpack/v1/adaptor/msgpack_tuple_decl.hpp
include/msgpack/v1/adaptor/nil.hpp
include/msgpack/v1/adaptor/nil_decl.hpp
include/msgpack/v1/adaptor/pair.hpp
include/msgpack/v1/adaptor/raw.hpp
include/msgpack/v1/adaptor/raw_decl.hpp
include/msgpack/v1/adaptor/set.hpp
include/msgpack/v1/adaptor/size_equal_only.hpp
include/msgpack/v1/adaptor/size_equal_only_decl.hpp
include/msgpack/v1/adaptor/string.hpp
include/msgpack/v1/adaptor/tr1/unordered_map.hpp
include/msgpack/v1/adaptor/tr1/unordered_set.hpp
include/msgpack/v1/adaptor/v4raw.hpp
include/msgpack/v1/adaptor/v4raw_decl.hpp
include/msgpack/v1/adaptor/vector.hpp
include/msgpack/v1/adaptor/vector_bool.hpp
include/msgpack/v1/adaptor/vector_char.hpp
include/msgpack/v1/adaptor/vector_unsigned_char.hpp
include/msgpack/v1/adaptor/wstring.hpp
include/msgpack/v1/cpp_config.hpp
include/msgpack/v1/cpp_config_decl.hpp
include/msgpack/v1/detail/cpp03_zone.hpp
include/msgpack/v1/detail/cpp03_zone_decl.hpp
include/msgpack/v1/detail/cpp11_zone.hpp
include/msgpack/v1/detail/cpp11_zone_decl.hpp
include/msgpack/v1/fbuffer.hpp
include/msgpack/v1/fbuffer_decl.hpp
include/msgpack/v1/iterator.hpp
include/msgpack/v1/iterator_decl.hpp
include/msgpack/v1/meta.hpp
include/msgpack/v1/meta_decl.hpp
include/msgpack/v1/object.hpp
include/msgpack/v1/object_decl.hpp
include/msgpack/v1/object_fwd.hpp
include/msgpack/v1/object_fwd_decl.hpp
include/msgpack/v1/pack.hpp
include/msgpack/v1/pack_decl.hpp
include/msgpack/v1/parse_return.hpp
include/msgpack/v1/sbuffer.hpp
include/msgpack/v1/sbuffer_decl.hpp
include/msgpack/v1/unpack.hpp
include/msgpack/v1/unpack_decl.hpp
include/msgpack/v1/unpack_exception.hpp
include/msgpack/v1/version.hpp
include/msgpack/v1/versioning.hpp
include/msgpack/v1/vrefbuffer.hpp
include/msgpack/v1/vrefbuffer_decl.hpp
include/msgpack/v1/zbuffer.hpp
include/msgpack/v1/zbuffer_decl.hpp
include/msgpack/v1/zone.hpp
include/msgpack/v1/zone_decl.hpp
include/msgpack/v2/adaptor/adaptor_base.hpp
include/msgpack/v2/adaptor/adaptor_base_decl.hpp
include/msgpack/v2/adaptor/array_ref_decl.hpp
include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp
include/msgpack/v2/adaptor/check_container_size_decl.hpp
include/msgpack/v2/adaptor/define_decl.hpp
include/msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp
include/msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp
include/msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
include/msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp
include/msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp
include/msgpack/v2/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
include/msgpack/v2/adaptor/ext_decl.hpp
include/msgpack/v2/adaptor/fixint_decl.hpp
include/msgpack/v2/adaptor/int_decl.hpp
include/msgpack/v2/adaptor/map_decl.hpp
include/msgpack/v2/adaptor/msgpack_tuple_decl.hpp
include/msgpack/v2/adaptor/nil_decl.hpp
include/msgpack/v2/adaptor/raw_decl.hpp
include/msgpack/v2/adaptor/size_equal_only_decl.hpp
include/msgpack/v2/adaptor/v4raw_decl.hpp
include/msgpack/v2/cpp_config_decl.hpp
include/msgpack/v2/create_object_visitor.hpp
include/msgpack/v2/create_object_visitor_decl.hpp
include/msgpack/v2/detail/cpp03_zone_decl.hpp
include/msgpack/v2/detail/cpp11_zone_decl.hpp
include/msgpack/v2/fbuffer_decl.hpp
include/msgpack/v2/iterator_decl.hpp
include/msgpack/v2/meta_decl.hpp
include/msgpack/v2/null_visitor.hpp
include/msgpack/v2/null_visitor_decl.hpp
include/msgpack/v2/object.hpp
include/msgpack/v2/object_decl.hpp
include/msgpack/v2/object_fwd.hpp
include/msgpack/v2/object_fwd_decl.hpp
include/msgpack/v2/pack_decl.hpp
include/msgpack/v2/parse.hpp
include/msgpack/v2/parse_decl.hpp
include/msgpack/v2/parse_return.hpp
include/msgpack/v2/sbuffer_decl.hpp
include/msgpack/v2/unpack.hpp
include/msgpack/v2/unpack_decl.hpp
include/msgpack/v2/vrefbuffer_decl.hpp
include/msgpack/v2/x3_parse.hpp
include/msgpack/v2/x3_parse_decl.hpp
include/msgpack/v2/x3_unpack.hpp
include/msgpack/v2/x3_unpack_decl.hpp
include/msgpack/v2/zbuffer_decl.hpp
include/msgpack/v2/zone_decl.hpp
include/msgpack/v3/adaptor/adaptor_base.hpp
include/msgpack/v3/adaptor/adaptor_base_decl.hpp
include/msgpack/v3/adaptor/array_ref_decl.hpp
include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp
include/msgpack/v3/adaptor/check_container_size_decl.hpp
include/msgpack/v3/adaptor/define_decl.hpp
include/msgpack/v3/adaptor/detail/cpp03_define_array_decl.hpp
include/msgpack/v3/adaptor/detail/cpp03_define_map_decl.hpp
include/msgpack/v3/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
include/msgpack/v3/adaptor/detail/cpp11_define_array_decl.hpp
include/msgpack/v3/adaptor/detail/cpp11_define_map_decl.hpp
include/msgpack/v3/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
include/msgpack/v3/adaptor/ext_decl.hpp
include/msgpack/v3/adaptor/fixint_decl.hpp
include/msgpack/v3/adaptor/int_decl.hpp
include/msgpack/v3/adaptor/map_decl.hpp
include/msgpack/v3/adaptor/msgpack_tuple_decl.hpp
include/msgpack/v3/adaptor/nil_decl.hpp
include/msgpack/v3/adaptor/raw_decl.hpp
include/msgpack/v3/adaptor/size_equal_only_decl.hpp
include/msgpack/v3/adaptor/v4raw_decl.hpp
include/msgpack/v3/cpp_config_decl.hpp
include/msgpack/v3/create_object_visitor_decl.hpp
include/msgpack/v3/detail/cpp03_zone_decl.hpp
include/msgpack/v3/detail/cpp11_zone_decl.hpp
include/msgpack/v3/fbuffer_decl.hpp
include/msgpack/v3/iterator_decl.hpp
include/msgpack/v3/meta_decl.hpp
include/msgpack/v3/null_visitor_decl.hpp
include/msgpack/v3/object_decl.hpp
include/msgpack/v3/object_fwd.hpp
include/msgpack/v3/object_fwd_decl.hpp
include/msgpack/v3/pack_decl.hpp
include/msgpack/v3/parse.hpp
include/msgpack/v3/parse_decl.hpp
include/msgpack/v3/parse_return.hpp
include/msgpack/v3/sbuffer_decl.hpp
include/msgpack/v3/unpack.hpp
include/msgpack/v3/unpack_decl.hpp
include/msgpack/v3/vrefbuffer_decl.hpp
include/msgpack/v3/x3_parse_decl.hpp
include/msgpack/v3/x3_unpack.hpp
include/msgpack/v3/x3_unpack_decl.hpp
include/msgpack/v3/zbuffer_decl.hpp
include/msgpack/v3/zone_decl.hpp
include/msgpack/version.hpp
include/msgpack/version_master.hpp
include/msgpack/versioning.hpp
include/msgpack/vrefbuffer.hpp
include/msgpack/vrefbuffer_decl.hpp
include/msgpack/x3_parse.hpp
include/msgpack/x3_parse_decl.hpp
include/msgpack/x3_unpack.hpp
include/msgpack/x3_unpack_decl.hpp
include/msgpack/zbuffer.hpp
include/msgpack/zbuffer_decl.hpp
include/msgpack/zone.hpp
include/msgpack/zone_decl.hpp
)

159
QUICKSTART-CPP.md
View File

@ -1,159 +0,0 @@
# Implementation Status
The serialization library is production-ready.
Currently, RPC implementation is in testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
# Install
Same as QuickStart for C Language.
# Serialization QuickStart for C+\+
## First program
Include `msgpack.hpp` header to use MessagePack on your program.
```cpp
#include <msgpack.hpp>
#include <vector>
#include <string>
#include <iostream>
int main(void) {
// serializes this object.
std::vector<std::string> vec;
vec.push_back("Hello");
vec.push_back("MessagePack");
// serialize it into simple buffer.
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec);
// deserialize it.
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
// print the deserialized object.
msgpack::object obj = oh.get();
std::cout << obj << std::endl; //=> ["Hello", "MessagePack"]
// convert it into statically typed object.
std::vector<std::string> rvec;
obj.convert(rvec);
}
```
Compile it as follows:
```
$ g++ -Ipath_to_msgpack/include hello.cc -o hello
$ ./hello
["Hello", "MessagePack"]
```
## Streaming feature
```cpp
#include <msgpack.hpp>
#include <iostream>
#include <string>
int main() {
// serializes multiple objects using msgpack::packer.
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(std::string("Log message ... 1"));
pk.pack(std::string("Log message ... 2"));
pk.pack(std::string("Log message ... 3"));
// deserializes these objects using msgpack::unpacker.
msgpack::unpacker pac;
// feeds the buffer.
pac.reserve_buffer(buffer.size());
memcpy(pac.buffer(), buffer.data(), buffer.size());
pac.buffer_consumed(buffer.size());
// now starts streaming deserialization.
msgpack::object_handle oh;
while(pac.next(oh)) {
std::cout << oh.get() << std::endl;
}
// results:
// $ g++ -Ipath_to_msgpack/include stream.cc -o stream
// $ ./stream
// "Log message ... 1"
// "Log message ... 2"
// "Log message ... 3"
}
```
### Streaming into an array or map
```cpp
#include <msgpack.hpp>
#include <iostream>
#include <string>
int main() {
// serializes multiple objects into one message containing an array using msgpack::packer.
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack_array(3);
pk.pack(std::string("Log message ... 1"));
pk.pack(std::string("Log message ... 2"));
pk.pack(std::string("Log message ... 3"));
// serializes multiple objects into one message containing a map using msgpack::packer.
msgpack::sbuffer buffer2;
msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
pk2.pack_map(2);
pk2.pack(std::string("x"));
pk2.pack(3);
pk2.pack(std::string("y"));
pk2.pack(3.4321);
}
```
## User-defined classes
You can use serialize/deserializes user-defined classes using `MSGPACK_DEFINE` macro.
```cpp
#include <msgpack.hpp>
#include <vector>
#include <string>
class myclass {
private:
std::string m_str;
std::vector<int> m_vec;
public:
MSGPACK_DEFINE(m_str, m_vec);
};
int main() {
std::vector<myclass> vec;
// add some elements into vec...
// you can serialize myclass directly
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::object obj = oh.get();
// you can convert object to myclass directly
std::vector<myclass> rvec;
obj.convert(rvec);
}
```

193
README.md
View File

@ -1,9 +1,6 @@
`msgpack` for C++
`msgpack` for C/C++
===================
Version 7.0.0 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=cpp_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/cpp_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master)
It's like JSON but smaller and faster.
Overview
@ -15,193 +12,15 @@ except that it's faster and smaller. Small integers are encoded into a
single byte and short strings require only one extra byte in
addition to the strings themselves.
Example
-------
### C Library
```c++
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
See [c_master](https://github.com/msgpack/msgpack-c/tree/c_master)
int main()
{
msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
### C++ Library
// 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);
See [cpp_master](https://github.com/msgpack/msgpack-c/tree/cpp_master)
// send the buffer ...
buffer.seekg(0);
// deserialize the buffer into msgpack::object instance.
std::string str(buffer.str());
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
// deserialized object is valid during the msgpack::object_handle instance is alive.
msgpack::object deserialized = oh.get();
// msgpack::object supports ostream.
std::cout << deserialized << std::endl;
// convert msgpack::object instance into the original type.
// if the type is mismatched, it throws msgpack::type_error exception.
msgpack::type::tuple<int, bool, std::string> dst;
deserialized.convert(dst);
// or create the new instance
msgpack::type::tuple<int, bool, std::string> dst2 =
deserialized.as<msgpack::type::tuple<int, bool, std::string> >();
return 0;
}
```
See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
Dependency
----------
msgpack-c requires [boost library](https://www.boost.org/).
C++ version of msgpack-c itself is a header-only library and depends only on
boost headers. Tests depend on boost unit test framework and are linked with
it, so if you want to build them, you need to have this dependency installed.
Experimental support for removing boost dependency
For cmake:
```
cmake -DMSGPACK_USE_BOOST=OFF ..
```
NOTE: `-DMSGPACK_BUILD_TESTS=ON` doesn't work with `-DMSGPACK_USE_BOOST=OFF`.
For C++ compiler
```
clang++ -DMSGPACK_NO_BOOST your_code.cpp
```
Usage
-----
- If you build your project with cmake, you can find msgpack-c with a
canonical cmake-way:
```cmake
# ...
find_package(msgpack REQUIRED)
# ...
target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE> msgpack-cxx)
# ...
```
This will search for `msgpack` cmake package in a system prefix and in
prefixes from `CMAKE_PREFIX_PATH`. Note that msgpack-c depends on boost
headers, and `msgpack` cmake package depends on `Boost` cmake package. The
library is header-only and `target_link_libraries` command just adds path
to msgpack-c headers to your compiler's include path.
A usage example can be found at [test-install](test-install) directory.
- If you do not use cmake, you can just add path yo msgpack-c and boost
headers to your include path:
```bash
g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp
```
Building and Installing
-----------------------
### Install from git repository
#### Using the Terminal (CLI)
You will need:
- `gcc >= 4.1.0`
- `cmake >= 3.1.0`
C++03:
```bash
git clone https://github.com/msgpack/msgpack-c.git
cd msgpack-c
git checkout cpp_master
cmake .
sudo cmake --build . --target install
```
If you want to build tests with different C++ version, you can use
`MSGPACK_CXX11`, `MSGPACK_CXX14`, `MSGPACK_CXX17`, `MSGPACK_CXX20` options.
Just replace the line
```bash
cmake .
```
with a line like that:
```bash
cmake -DMSGPACK_CXX20=ON .
```
Note that these flags do not affect installation. They just switch test cases.
All files are installed in every settings.
If you don't have superuser permissions or don't want to install the library
to a system-wide prefix, you can use `CMAKE_INSTALL_PREFIX` option like that:
```bash
cmake -DCMAKE_INSTALL_PREFIX=/your/custom/prefix .
```
Other useful options:
- `MSGPACK_BUILD_TESTS` (default `OFF`): build tests
- `MSGPACK_BUILD_EXAMPLES` (default `OFF`): build examples
- `MSGPACK_32BIT` (default `OFF`): 32bit compile
- `MSGPACK_USE_X3_PARSE` (default `OFF`): use Boost X3 parse
(note that it requires C++14 or newer)
- `MSGPACK_CHAR_SIGN` (not set explicitly by default): char sign to use (signed or unsigned)
- `MSGPACK_USE_STATIC_BOOST` (default `OFF`): statically link with boost libraries
#### GUI on Windows
Clone msgpack-c git repository with the command:
```
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. Checkout to `cpp_master` branch
2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
3. Set 'Where is the source code:' text box and
'Where to build the binaries:' text box.
4. Click 'Configure' button.
5. Choose your Visual Studio version.
6. Click 'Generate' button.
7. Open the created msgpack.sln on Visual Studio.
8. Build all.
Documentation
-------------
### Documentation
You can get additional information including the tutorial on the
[wiki](https://github.com/msgpack/msgpack-c/wiki).

56
appveyor.yml
View File

@ -1,56 +0,0 @@
version: 7.0.0.{build}
branches:
only:
- cpp_master
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
cpp11: -DMSGPACK_CXX11=ON
msvc: '"Visual Studio 14 2015"'
boost_prefix: C:\Libraries\boost_1_69_0
boost_subdir: lib32-msvc-14.0
build_script:
- ps: |
appveyor DownloadFile http://zlib.net/zlib-1.3.1.tar.gz -FileName zlib-1.3.1.tar.gz
7z x zlib-1.3.1.tar.gz 2> $null
7z x zlib-1.3.1.tar 2> $null
cd zlib-1.3.1
md build
md prefix
cd build
cmake `
-G $env:msvc `
-D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\zlib-1.3.1\prefix" `
..
if ($LastExitCode -ne 0) { exit $LastExitCode }
cmake --build . --target install --config Release
if ($LastExitCode -ne 0) { exit $LastExitCode }
cd ..\..
md build
md prefix
cd build
cmake `
-G $env:msvc `
$env:cpp11 `
-D MSGPACK_BUILD_EXAMPLES=ON `
-D MSGPACK_BUILD_TESTS=ON `
-D CMAKE_EXE_LINKER_FLAGS=/LIBPATH:"$env:boost_prefix\$env:boost_subdir" `
-D CMAKE_PREFIX_PATH="$env:boost_prefix;$env:APPVEYOR_BUILD_FOLDER\zlib-1.3.1\prefix" `
-D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\prefix" `
-D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /DBOOST_ALL_DYN_LINK" `
..
if ($LastExitCode -ne 0) { exit $LastExitCode }
cmake --build . --config Release
if ($LastExitCode -ne 0) { exit $LastExitCode }
test_script:
- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\zlib-1.3.1\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release;%boost_prefix%\%boost_subdir%
- ctest -VV -C Release

61
ci/build_cmake.sh
View File

@ -1,61 +0,0 @@
#!/bin/bash
build_dir="$CXX-build"
prefix_dir="`pwd`/$CXX-prefix"
mkdir $build_dir || exit 1
mkdir $prefix_dir || exit 1
if [ "${ARCH}" == "32" ]; then
export BIT32="ON"
export ARCH_FLAG="-m32"
else
export BIT32="OFF"
export ARCH_FLAG="-m64"
fi
cmake \
-D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
-D MSGPACK_BUILD_TESTS=ON \
-D ${MSGPACK_CXX_VERSION} \
-D MSGPACK_32BIT=${BIT32} \
-D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
-D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
-D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
-D MSGPACK_USE_STD_VARIANT_ADAPTOR=${STD_VARIANT_ADAPTOR} \
-D CMAKE_CXX_FLAGS="${CXXFLAGS} ${ARCH_FLAG}" \
-D CMAKE_INSTALL_PREFIX=$prefix_dir \
-B $build_dir \
-S . || exit 1
cmake --build $build_dir --target install || exit 1
ctest -VV --test-dir $build_dir || exit 1
if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]; then
ctest -T memcheck --test-dir $build_dir | 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
if [ "${ARCH}" != "32" ]; then
cd test-install || exit 1
mkdir $build_dir
cmake \
-D CMAKE_PREFIX_PATH="$prefix_dir;${HOME}/boost-prefix/${ARCH}" \
-B $build_dir \
-S . || exit 1
cmake --build $build_dir --target all || exit 1
$build_dir/test-install || exit 1
fi

25
ci/build_regression.sh
View File

@ -1,25 +0,0 @@
#!/bin/bash
build_dir="$CXX-build"
mkdir $build_dir || exit 1
if [ "${ARCH}" == "32" ]
then
echo "64 bit support required for regressions"
exit 1
fi
cmake \
-D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
-D MSGPACK_FUZZ_REGRESSION="ON" \
-D ${MSGPACK_CXX_VERSION} \
-D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
-D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
-D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
-D CMAKE_CXX_FLAGS="${CXXFLAGS}" \
-B $build_dir \
-S . || exit 1
cmake --build $build_dir --target all || exit 1
ctest -VV --test-dir $build_dir || exit 1

17
ci/set_gcc_10.sh
View File

@ -1,17 +0,0 @@
#!/bin/bash
version=10
priority=100
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcov gcov /usr/bin/gcov-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcov-dump gcov-dump /usr/bin/gcov-dump-${version} ${priority}
sudo update-alternatives --install /usr/bin/gcov-tool gcov-tool /usr/bin/gcov-tool-${version} ${priority}
sudo update-alternatives --install /usr/bin/lto-dump lto-dump /usr/bin/lto-dump-${version} ${priority}
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-${version} ${priority}
sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc-${version} ${priority}
sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++-${version} ${priority}

55
cmake/CodeCoverage.cmake
View File

@ -1,55 +0,0 @@
# Check prereqs
FIND_PROGRAM(GCOV_PATH gcov)
FIND_PROGRAM(LCOV_PATH lcov)
FIND_PROGRAM(GENHTML_PATH genhtml)
IF(NOT GCOV_PATH)
MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
ENDIF()
IF(NOT CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_GNUCXX)
# Clang version 3.0.0 and greater now supports gcov as well.
MESSAGE(STATUS "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.")
IF(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang" AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
ENDIF()
ENDIF()
SET(COVERAGE_FLAGS "-g -O0 --coverage")
FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
IF(NOT LCOV_PATH)
MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
ENDIF()
IF(NOT GENHTML_PATH)
MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
ENDIF()
# Setup target
ADD_CUSTOM_TARGET(${_targetname}
# Cleanup lcov
${LCOV_PATH} --directory . --zerocounters
# Run tests
COMMAND ${_testrunner} ${ARGV3}
# Capturing lcov counters and generating report
COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info --base-directory ${CMAKE_SOURCE_DIR} --no-external --quiet
COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/test/*' '*/fuzz/*' --output-file ${_outputname}.info.cleaned --quiet
COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned --prefix ${CMAKE_SOURCE_DIR}
# COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
)
# Show info where to find the report
ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
COMMAND ;
COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
)
ENDFUNCTION()

36
codecov.yml
View File

@ -1,36 +0,0 @@
codecov:
notify:
require_ci_to_pass: yes
coverage:
precision: 2
round: down
range: "70...100"
status:
project: yes
patch: yes
changes: no
parsers:
gcov:
branch_detection:
conditional: yes
loop: yes
method: no
macro: no
comment:
layout: "header, diff"
behavior: default
require_changes: no
ignore:
- "test"
- "fuzz"
- "erb"
- "ci"
- "cmake"
- "examle"
- "external"
- "usr"

110
erb/v1/cpp03_define_array.hpp.erb
View File

@ -1,110 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
#define MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
#include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp"
#include "msgpack/adaptor/msgpack_tuple.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/object_fwd.hpp"
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
<% GENERATION_LIMIT = 31 %>
template <>
struct define_array<> {
typedef define_array<> value_type;
typedef tuple<> tuple_type;
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
pk.pack_array(0);
}
void msgpack_unpack(msgpack::object const& o)
{
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
}
void msgpack_object(msgpack::object* o, msgpack::zone&) const
{
o->type = msgpack::type::ARRAY;
o->via.array.ptr = MSGPACK_NULLPTR;
o->via.array.size = 0;
}
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
typedef define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
define_array(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
pk.pack_array(<%=i+1%>);
<%0.upto(i) {|j|%>
pk.pack(a<%=j%>);<%}%>
}
void msgpack_unpack(msgpack::object const& o)
{
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
const size_t size = o.via.array.size;
if(size > 0) {
msgpack::object *ptr = o.via.array.ptr;
switch(size) {
default:<%(i).downto(0) {|j|%>
case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);
// fallthrough
<%}%>
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = msgpack::type::ARRAY;
o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
o->via.array.size = <%=i+1%>;
<%0.upto(i) {|j|%>
o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>
}
<%0.upto(i) {|j|%>
A<%=j%>& a<%=j%>;<%}%>
};
<%}%>
/// @endcond
inline define_array<> make_define_array()
{
return define_array<>();
}
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
{
return define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
}
<%}%>
/// @endcond
} // namespace type
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP

42
erb/v1/cpp03_define_array_decl.hpp.erb
View File

@ -1,42 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
#define MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
#include "msgpack/versioning.hpp"
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
/// @cond
<% GENERATION_LIMIT = 31 %>
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
struct define_array;
/// @endcond
define_array<> make_define_array();
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>);
<%}%>
/// @endcond
} // namespace type
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP

120
erb/v1/cpp03_define_map.hpp.erb
View File

@ -1,120 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015-2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_DEFINE_MAP_HPP
#define MSGPACK_V1_CPP03_DEFINE_MAP_HPP
#include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp"
#include "msgpack/adaptor/msgpack_tuple.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/object_fwd.hpp"
#include <map>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
<% GENERATION_LIMIT = 31 %>
template <>
struct define_map<> {
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
pk.pack_map(0);
}
void msgpack_unpack(msgpack::object const& o) const
{
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
}
void msgpack_object(msgpack::object* o, msgpack::zone&) const
{
o->type = msgpack::type::MAP;
o->via.map.ptr = MSGPACK_NULLPTR;
o->via.map.size = 0;
}
};
/// @cond
<%1.step(GENERATION_LIMIT+1,2) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
define_map(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
pk.pack_map(<%=(i+1)/2%>);
<%0.upto(i) {|j|%>
pk.pack(a<%=j%>);<%}%>
}
void msgpack_unpack(msgpack::object const& o) const
{
if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
std::map<std::string, msgpack::object const*> kvmap;
for (uint32_t i = 0; i < o.via.map.size; ++i) {
if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
kvmap.insert(
std::map<std::string, msgpack::object const*>::value_type(
std::string(
o.via.map.ptr[i].key.via.str.ptr,
o.via.map.ptr[i].key.via.str.size),
&o.via.map.ptr[i].val
)
);
}
<%0.step(i,2) {|j|%>
{
std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a<%=j%>);
if (it != kvmap.end()) {
it->second->convert(a<%=j+1%>);
}
}
<%}%>
}
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = msgpack::type::MAP;
o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
o->via.map.size = <%=(i+1)/2%>;
<%0.step(i,2) {|j|%>
o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);
o->via.map.ptr[<%=j/2%>].val = msgpack::object(a<%=j+1%>, z);
<%}%>
}
<%0.upto(i) {|j|%>
A<%=j%>& a<%=j%>;<%}%>
};
<%}%>
/// @endcond
inline define_map<> make_define_map()
{
return define_map<>();
}
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
inline define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
{
return define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
}
<%}%>
/// @endcond
} // namespace type
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_DEFINE_MAP_HPP

42
erb/v1/cpp03_define_map_decl.hpp.erb
View File

@ -1,42 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015-2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
#define MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
#include "msgpack/versioning.hpp"
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
/// @cond
<% GENERATION_LIMIT = 31 %>
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
struct define_map;
/// @endcond
define_map<> make_define_map();
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>);
<%}%>
/// @endcond
} // namespace type
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP

227
erb/v1/cpp03_msgpack_tuple.hpp.erb
View File

@ -1,227 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
#include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
// FIXME operator==
// FIXME operator!=
<% GENERATION_LIMIT = 31 %>
template <typename T>
struct tuple_type {
typedef T type;
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
typedef const T& transparent_reference;
};
template <typename T>
struct tuple_type<T&> {
typedef T type;
typedef T& value_type;
typedef T& reference;
typedef const T& const_reference;
typedef T& transparent_reference;
};
template <typename T>
struct tuple_type<const T&> {
typedef T type;
typedef T& value_type;
typedef T& reference;
typedef const T& const_reference;
typedef const T& transparent_reference;
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
<%0.upto(i) {|j|%>
template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {}
typename tuple_type<A<%=j%>>::reference get() { return m_x; }
typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
private:
typename tuple_type<A<%=j%>>::reference m_x;
};
<%}%>
<%}%>
<%0.upto(GENERATION_LIMIT) {|i|%>
<%0.upto(i) {|j|%>
template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {}
typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
private:
typename tuple_type<A<%=j%>>::const_reference m_x;
};
<%}%>
<%}%>
/// @endcond
template <>
struct tuple<> {
tuple() {}
tuple(msgpack::object const& o) { o.convert(*this); }
typedef tuple<> value_type;
std::size_t size() const { return 0; }
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
std::size_t size() const { return <%=i+1%>; }
tuple() {}
tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
tuple(msgpack::object const& o) { o.convert(*this); }
template <int N> typename tuple_element<value_type, N>::reference get()
{ return tuple_element<value_type, N>(*this).get(); }
template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
{ return const_tuple_element<value_type, N>(*this).get(); }
<%0.upto(i) {|j|%>
A<%=j%> a<%=j%>;<%}%>
};
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
inline typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t)
{ return t.template get<N>(); }
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
inline typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t)
{ return t.template get<N>(); }
<%}%>
/// @endcond
inline tuple<> make_tuple()
{
return tuple<>();
}
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>)
{
return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
}
<%}%>
/// @endcond
} // namespace type
namespace adaptor {
template <>
struct convert<type::tuple<> > {
msgpack::object const& operator()(
msgpack::object const& o,
type::tuple<>&) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
return o;
}
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
msgpack::object const& operator()(
msgpack::object const& o,
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
<%0.upto(i) {|j|%>
// In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
if(o.via.array.size > <%=j%>)
o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
return o;
}
};
<%}%>
/// @endcond
template <>
struct pack<type::tuple<> > {
template <typename Stream>
msgpack::packer<Stream>& operator()(
msgpack::packer<Stream>& o,
const type::tuple<>&) const {
o.pack_array(0);
return o;
}
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct pack<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
template <typename Stream>
msgpack::packer<Stream>& operator()(
msgpack::packer<Stream>& o,
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
o.pack_array(<%=i+1%>);
<%0.upto(i) {|j|%>
o.pack(v.template get<<%=j%>>());<%}%>
return o;
}
};
<%}%>
/// @endcond
template <>
struct object_with_zone<type::tuple<> > {
void operator()(
msgpack::object::with_zone& o,
const type::tuple<>&) const {
o.type = msgpack::type::ARRAY;
o.via.array.ptr = MSGPACK_NULLPTR;
o.via.array.size = 0;
}
};
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
void operator()(
msgpack::object::with_zone& o,
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
o.type = msgpack::type::ARRAY;
o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
o.via.array.size = <%=i+1%>;
<%0.upto(i) {|j|%>
o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>
}
};
<%}%>
/// @endcond
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP

69
erb/v1/cpp03_msgpack_tuple_decl.hpp.erb
View File

@ -1,69 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/object.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace type {
// FIXME operator==
// FIXME operator!=
<% GENERATION_LIMIT = 31 %>
/// @cond
template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
struct tuple;
/// @endcond
template <typename Tuple, int N>
struct tuple_element;
template <typename Tuple, int N>
struct const_tuple_element;
template <typename T>
struct tuple_type;
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t);
template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t);
<%}%>
/// @endcond
tuple<> make_tuple();
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>);
<%}%>
/// @endcond
} // namespace type
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP

343
erb/v1/cpp03_zone.hpp.erb
View File

@ -1,343 +0,0 @@
//
// MessagePack for C++ memory pool
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_ZONE_HPP
#define MSGPACK_V1_CPP03_ZONE_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/cpp_config.hpp"
#include "msgpack/zone_decl.hpp"
#include "msgpack/assert.hpp"
#include <stdint.h>
#include <cstdlib>
#include <memory>
#include <vector>
<% GENERATION_LIMIT = 15 %>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
class zone {
struct finalizer {
finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
void operator()() { m_func(m_data); }
void (*m_func)(void*);
void* m_data;
};
struct finalizer_array {
finalizer_array():m_tail(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_NULLPTR) {}
void call() {
finalizer* fin = m_tail;
for(; fin != m_array; --fin) (*(fin-1))();
}
~finalizer_array() {
call();
::free(m_array);
}
void clear() {
call();
m_tail = m_array;
}
void push(void (*func)(void* data), void* data)
{
finalizer* fin = m_tail;
if(fin == m_end) {
push_expand(func, data);
return;
}
fin->m_func = func;
fin->m_data = data;
++m_tail;
}
void push_expand(void (*func)(void*), void* data) {
const size_t nused = static_cast<size_t>(m_end - m_array);
size_t nnext;
if(nused == 0) {
nnext = (sizeof(finalizer) < 72/2) ?
72 / sizeof(finalizer) : 8;
} else {
nnext = nused * 2;
}
finalizer* tmp =
static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
if(!tmp) {
throw std::bad_alloc();
}
m_array = tmp;
m_end = tmp + nnext;
m_tail = tmp + nused;
new (m_tail) finalizer(func, data);
++m_tail;
}
finalizer* m_tail;
finalizer* m_end;
finalizer* m_array;
};
struct chunk {
chunk* m_next;
};
struct chunk_list {
chunk_list(size_t chunk_size)
{
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
if(!c) {
throw std::bad_alloc();
}
m_head = c;
m_free = chunk_size;
m_ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
c->m_next = MSGPACK_NULLPTR;
}
~chunk_list()
{
chunk* c = m_head;
while(c) {
chunk* n = c->m_next;
::free(c);
c = n;
}
}
void clear(size_t chunk_size)
{
chunk* c = m_head;
while(true) {
chunk* n = c->m_next;
if(n) {
::free(c);
c = n;
} else {
m_head = c;
break;
}
}
m_head->m_next = MSGPACK_NULLPTR;
m_free = chunk_size;
m_ptr = reinterpret_cast<char*>(m_head) + sizeof(chunk);
}
size_t m_free;
char* m_ptr;
chunk* m_head;
};
size_t m_chunk_size;
chunk_list m_chunk_list;
finalizer_array m_finalizer_array;
public:
zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
public:
void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
void* allocate_no_align(size_t size);
void push_finalizer(void (*func)(void*), void* data);
template <typename T>
void push_finalizer(msgpack::unique_ptr<T> obj);
void clear();
void swap(zone& o);
static void* operator new(std::size_t size)
{
void* p = ::malloc(size);
if (!p) throw std::bad_alloc();
return p;
}
static void operator delete(void *p) /* throw() */
{
::free(p);
}
static void* operator new(std::size_t size, void* place) /* throw() */
{
return ::operator new(size, place);
}
static void operator delete(void* p, void* place) /* throw() */
{
::operator delete(p, place);
}
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
<%}%>
/// @endcond
private:
void undo_allocate(size_t size);
template <typename T>
static void object_destruct(void* obj);
template <typename T>
static void object_delete(void* obj);
static char* get_aligned(char* ptr, size_t align);
char* allocate_expand(size_t size);
private:
zone(const zone&);
zone& operator=(const zone&);
};
inline zone::zone(size_t chunk_size):m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
{
}
inline char* zone::get_aligned(char* ptr, size_t align)
{
MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0)
return
reinterpret_cast<char*>(
reinterpret_cast<uintptr_t>(ptr + (align - 1)) & ~static_cast<uintptr_t>(align - 1)
);
}
inline void* zone::allocate_align(size_t size, size_t align)
{
char* aligned = get_aligned(m_chunk_list.m_ptr, align);
size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
if (m_chunk_list.m_free < adjusted_size) {
size_t enough_size = size + align - 1;
char* ptr = allocate_expand(enough_size);
aligned = get_aligned(ptr, align);
adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
}
m_chunk_list.m_free -= adjusted_size;
m_chunk_list.m_ptr += adjusted_size;
return aligned;
}
inline void* zone::allocate_no_align(size_t size)
{
char* ptr = m_chunk_list.m_ptr;
if(m_chunk_list.m_free < size) {
ptr = allocate_expand(size);
}
m_chunk_list.m_free -= size;
m_chunk_list.m_ptr += size;
return ptr;
}
inline char* zone::allocate_expand(size_t size)
{
chunk_list* const cl = &m_chunk_list;
size_t sz = m_chunk_size;
while(sz < size) {
size_t tmp_sz = sz * 2;
if (tmp_sz <= sz) {
sz = size;
break;
}
sz = tmp_sz;
}
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
if (!c) throw std::bad_alloc();
char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
c->m_next = cl->m_head;
cl->m_head = c;
cl->m_free = sz;
cl->m_ptr = ptr;
return ptr;
}
inline void zone::push_finalizer(void (*func)(void*), void* data)
{
m_finalizer_array.push(func, data);
}
template <typename T>
inline void zone::push_finalizer(msgpack::unique_ptr<T> obj)
{
m_finalizer_array.push(&zone::object_delete<T>, obj.release());
}
inline void zone::clear()
{
m_finalizer_array.clear();
m_chunk_list.clear(m_chunk_size);
}
inline void zone::swap(zone& o)
{
using std::swap;
swap(m_chunk_size, o.m_chunk_size);
swap(m_chunk_list, o.m_chunk_list);
swap(m_finalizer_array, o.m_finalizer_array);
}
template <typename T>
void zone::object_destruct(void* obj)
{
static_cast<T*>(obj)->~T();
}
template <typename T>
void zone::object_delete(void* obj)
{
delete static_cast<T*>(obj);
}
inline void zone::undo_allocate(size_t size)
{
m_chunk_list.m_ptr -= size;
m_chunk_list.m_free += size;
}
inline std::size_t aligned_size(
std::size_t size,
std::size_t align) {
return (size + align - 1) / align * align;
}
/// @cond
<%0.upto(GENERATION_LIMIT) {|i|%>
template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
{
void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
try {
m_finalizer_array.push(&zone::object_destruct<T>, x);
} catch (...) {
undo_allocate(sizeof(T));
throw;
}
try {
return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
} catch (...) {
--m_finalizer_array.m_tail;
undo_allocate(sizeof(T));
throw;
}
}
<%}%>
/// @endcond
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_ZONE_HPP

54
erb/v1/cpp03_zone_decl.hpp.erb
View File

@ -1,54 +0,0 @@
//
// MessagePack for C++ memory pool
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_CPP03_ZONE_DECL_HPP
#define MSGPACK_V1_CPP03_ZONE_DECL_HPP
#include <cstdlib>
#include <memory>
#include <vector>
#include "msgpack/versioning.hpp"
#ifndef MSGPACK_ZONE_CHUNK_SIZE
#define MSGPACK_ZONE_CHUNK_SIZE 8192
#endif
#ifndef MSGPACK_ZONE_ALIGN
#define MSGPACK_ZONE_ALIGN sizeof(void*)
#endif
#if defined(_MSC_VER)
#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
#else
#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
#endif
// For a compiler that doesn't support __alignof__:
// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
<% GENERATION_LIMIT = 15 %>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
class zone;
std::size_t aligned_size(
std::size_t size,
std::size_t align = MSGPACK_ZONE_ALIGN);
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_V1_CPP03_ZONE_DECL_HPP

9
example/CMakeLists.txt
View File

@ -1,9 +0,0 @@
ADD_SUBDIRECTORY (cpp03)
ADD_SUBDIRECTORY (cpp11)
IF (MSGPACK_USE_BOOST)
ADD_SUBDIRECTORY (boost)
IF (MSGPACK_USE_X3_PARSE)
ADD_SUBDIRECTORY (x3)
ENDIF ()
ENDIF ()

45
example/boost/CMakeLists.txt
View File

@ -1,45 +0,0 @@
FIND_PACKAGE (Boost REQUIRED)
FIND_PACKAGE (Threads REQUIRED)
FIND_PACKAGE (ZLIB REQUIRED)
LIST (APPEND exec_PROGRAMS
msgpack_variant_capitalize.cpp
msgpack_variant_mapbased.cpp
)
IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
LIST (APPEND exec_PROGRAMS asio_send_recv.cpp)
IF (ZLIB_FOUND)
LIST (APPEND exec_PROGRAMS asio_send_recv_zlib.cpp)
ENDIF ()
ENDIF ()
FOREACH (source_file ${exec_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
Threads::Threads
)
IF (ZLIB_FOUND)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE ZLIB::ZLIB)
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()

104
example/boost/asio_send_recv.cpp
View File

@ -1,104 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <sstream>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <msgpack.hpp>
int main() {
boost::asio::io_service ios;
std::uint16_t const port = 12345;
// Server
std::size_t const window_size = 10;
boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
boost::asio::ip::tcp::socket ss(ios);
std::function<void()> do_accept;
std::function<void()> do_async_read_some;
msgpack::unpacker unp;
do_accept = [&] {
ac.async_accept(
ss,
[&]
(boost::system::error_code const& e) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
do_async_read_some = [&] {
unp.reserve_buffer(window_size);
ss.async_read_some(
boost::asio::buffer(unp.buffer(), window_size),
[&](boost::system::error_code const& e, std::size_t bytes_transferred) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
std::cout << bytes_transferred << " bytes read." << std::endl;
unp.buffer_consumed(bytes_transferred);
msgpack::object_handle oh;
while (unp.next(oh)) {
std::cout << oh.get() << std::endl;
// In order to finish the program,
// return if one complete msgpack is processed.
// In actual server, don't return here.
return;
}
do_async_read_some();
}
);
};
do_async_read_some();
}
);
};
do_accept();
// Client
auto host = "localhost";
boost::asio::ip::tcp::resolver r(ios);
#if BOOST_VERSION < 106600
boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
auto it = r.resolve(q);
boost::asio::ip::tcp::resolver::iterator end;
#else // BOOST_VERSION < 106600
auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
auto it = eps.begin();
auto end = eps.end();
#endif // BOOST_VERSION < 106600
boost::asio::ip::tcp::socket cs(ios);
boost::asio::async_connect(
cs,
it,
end,
[&]
(boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
std::cout << __LINE__ << ":client connected" << std::endl;
msgpack::sbuffer sb;
msgpack::pack(sb, std::make_tuple(42, false, "hello world", 12.3456));
write(cs, boost::asio::buffer(sb.data(), sb.size()));
}
);
// Start
ios.run();
}

176
example/boost/asio_send_recv_zlib.cpp
View File

@ -1,176 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <sstream>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <msgpack.hpp>
#include <msgpack/zbuffer.hpp>
#include <zlib.h>
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
boost::asio::io_service ios;
std::uint16_t const port = 12345;
int num_of_zlib_data = 2;
int idx_zlib_data = 0;
// Server
std::size_t const window_size = 11;
boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
boost::asio::ip::tcp::socket ss(ios);
std::function<void()> do_accept;
std::function<void()> do_async_read_some;
// zlib for decompress
z_stream strm;
auto zlib_init = [&] {
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.next_in = Z_NULL;
{
int zret = inflateInit(&strm);
if (zret != Z_OK) {
std::cout << "Zlib inflateInit() error = " << zret << std::endl;
}
}
};
zlib_init();
std::vector<char> buf(4); // buf size
msgpack::unpacker unp;
do_accept = [&] {
ac.async_accept(
ss,
[&]
(boost::system::error_code const& e) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
do_async_read_some = [&] {
ss.async_read_some(
boost::asio::buffer(buf),
[&](boost::system::error_code const& e, std::size_t bytes_transferred) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
std::cout << bytes_transferred << " bytes read." << std::endl;
print(std::string(std::string(&buf[0], buf.size())));
strm.avail_in = static_cast<uInt>(bytes_transferred);
do {
strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in);
int zret;
unp.reserve_buffer(window_size);
strm.avail_out = static_cast<uInt>(window_size);
strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer());
do {
zret = inflate(&strm, Z_NO_FLUSH);
assert(zret != Z_STREAM_ERROR);
switch (zret) {
case Z_NEED_DICT:
zret = Z_DATA_ERROR;
// fall through
case Z_DATA_ERROR:
case Z_MEM_ERROR:
inflateEnd(&strm);
std::cout << "Zlib inflate() error = " << zret << std::endl;
std::exit(-1);
}
std::size_t decompressed_size = window_size - strm.avail_out;
std::cout << decompressed_size << " bytes decompressed." << std::endl;
unp.buffer_consumed(decompressed_size);
msgpack::object_handle oh;
while (unp.next(oh)) {
std::cout << oh.get() << std::endl;
}
} while (strm.avail_out == 0);
if (zret == Z_STREAM_END) {
inflateEnd(&strm);
std::cout << "Zlib decompress finished." << std::endl;
++idx_zlib_data;
if (idx_zlib_data == num_of_zlib_data) {
std::cout << "All zlib decompress finished." << std::endl;
return;
}
zlib_init();
}
} while (strm.avail_in != 0);
do_async_read_some();
}
);
};
do_async_read_some();
}
);
};
do_accept();
// Client
auto host = "localhost";
boost::asio::ip::tcp::resolver r(ios);
#if BOOST_VERSION < 106600
boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
auto it = r.resolve(q);
boost::asio::ip::tcp::resolver::iterator end;
#else // BOOST_VERSION < 106600
auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
auto it = eps.begin();
auto end = eps.end();
#endif // BOOST_VERSION < 106600
boost::asio::ip::tcp::socket cs(ios);
boost::asio::async_connect(
cs,
it,
end,
[&]
(boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
if (e) {
std::cout << __LINE__ << ":" << e.message() << std::endl;
return;
}
std::cout << __LINE__ << ":client connected" << std::endl;
for (int i = 0; i != num_of_zlib_data; ++i) {
msgpack::zbuffer zb;
msgpack::pack(zb, std::make_tuple(i, false, "hello world", 12.3456));
zb.flush(); // finalize zbuffer (don't forget it)
print(std::string(zb.data(), zb.size()));
write(cs, boost::asio::buffer(zb.data(), zb.size()));
}
}
);
// Start
ios.run();
}

94
example/boost/msgpack_variant_capitalize.cpp
View File

@ -1,94 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cctype>
#include <msgpack.hpp>
struct user {
std::string name;
int age;
std::string address;
MSGPACK_DEFINE(name, age, address);
};
struct proc:boost::static_visitor<void> {
void operator()(std::string& v) const {
std::cout << " match std::string& v" << std::endl;
std::cout << " v: " << v << std::endl;
std::cout << " capitalize" << std::endl;
for (std::string::iterator it = v.begin(), end = v.end();
it != end;
++it) {
*it = std::toupper(*it);
}
}
void operator()(std::vector<msgpack::type::variant>& v) const {
std::cout << "match vector (msgpack::type::ARRAY)" << std::endl;
std::vector<msgpack::type::variant>::iterator it = v.begin();
std::vector<msgpack::type::variant>::const_iterator end = v.end();
for (; it != end; ++it) {
boost::apply_visitor(*this, *it);
}
}
template <typename T>
void operator()(T const&) const {
std::cout << " match others" << std::endl;
}
};
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
std::stringstream ss1;
user u;
u.name = "Takatoshi Kondo";
u.age = 42;
u.address = "Tokyo, JAPAN";
std::cout << "Packing object." << std::endl;
msgpack::pack(ss1, u);
print(ss1.str());
msgpack::object_handle oh1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
msgpack::object const& obj1 = oh1.get();
std::cout << "Unpacked msgpack object." << std::endl;
std::cout << obj1 << std::endl;
msgpack::type::variant v = obj1.as<msgpack::type::variant>();
std::cout << "Applying proc..." << std::endl;
boost::apply_visitor(proc(), v);
std::stringstream ss2;
std::cout << "Packing modified object." << std::endl;
msgpack::pack(ss2, v);
print(ss2.str());
msgpack::object_handle oh2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
msgpack::object const& obj2 = oh2.get();
std::cout << "Modified msgpack object." << std::endl;
std::cout << obj2 << std::endl;
}

97
example/boost/msgpack_variant_mapbased.cpp
View File

@ -1,97 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <sstream>
#include <iostream>
#include <msgpack.hpp>
struct user {
std::string name;
int age;
std::string address;
MSGPACK_DEFINE_MAP(name, age, address);
};
struct proc:boost::static_visitor<void> {
// msgpack::type::MAP is converted to std::multimap, not std::map.
void operator()(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>& v) const {
std::cout << "match map" << std::endl;
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator it = v.begin();
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator end = v.end();
while(it != end) {
boost::string_ref const& key = it->first.as_boost_string_ref();
if (key == "name") {
boost::string_ref const& value = it->second.as_boost_string_ref();
if (value == "Takatoshi Kondo") {
// You can add values to msgpack::type::variant_ref.
v.insert(
std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::value_type(
"role",
"msgpack-c committer"
)
);
}
++it;
}
else if (key == "age") {
// You can remove key-value pair from msgpack::type::variant_ref
#if defined(MSGPACK_USE_CPP03)
# if MSGPACK_LIB_STD_CXX
v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it++));
# else // MSGPACK_LIB_STD_CXX
v.erase(it++);
# endif // MSGPACK_LIB_STD_CXX
#else // defined(MSGPACK_USE_CPP03)
# if MSGPACK_LIB_STD_CXX
it = v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it));
# else // MSGPACK_LIB_STD_CXX
it = v.erase(it);
# endif // MSGPACK_LIB_STD_CXX
#endif // defined(MSGPACK_USE_CPP03)
}
else if (key == "address") {
// When you want to append string
// "Tokyo" -> "Tokyo, JAPAN"
// Use msgpack::type::variant instead of msgpack::type::variant_ref
// or do as follows:
boost::string_ref const& value = it->second.as_boost_string_ref();
it->second = std::string(&value.front(), value.size()) + ", JAPAN";
++it;
}
}
}
template <typename T>
void operator()(T const&) const {
std::cout << " match others" << std::endl;
}
};
int main() {
std::stringstream ss;
user u;
u.name = "Takatoshi Kondo";
u.age = 42;
u.address = "Tokyo";
msgpack::pack(ss, u);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
msgpack::object const& obj = oh.get();
std::cout << "Unpacked msgpack object." << std::endl;
std::cout << obj << std::endl;
msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();
std::cout << "Applying proc..." << std::endl;
boost::apply_visitor(proc(), v);
msgpack::zone z;
std::cout << "Applied msgpack object." << std::endl;
std::cout << msgpack::object(v, z) << std::endl;
}

113
example/cpp03/CMakeLists.txt
View File

@ -1,113 +0,0 @@
FIND_PACKAGE (Threads REQUIRED)
FIND_PACKAGE (Boost COMPONENTS timer)
LIST (APPEND exec_PROGRAMS
class_intrusive.cpp
class_intrusive_map.cpp
class_non_intrusive.cpp
custom.cpp
enum.cpp
map_based_versionup.cpp
protocol_new.cpp
reuse_zone.cpp
simple.cpp
)
IF (MSGPACK_DEFAULT_API_VERSION EQUAL 1)
LIST (APPEND exec_PROGRAMS
protocol.cpp
)
ENDIF ()
IF (NOT MSVC)
LIST (APPEND with_pthread_PROGRAMS
stream.cpp
)
ENDIF ()
IF (MSGPACK_USE_BOOST)
IF (Boost_TIMER_LIBRARY)
LIST (APPEND with_boost_lib_PROGRAMS
speed_test.cpp
speed_test_nested_array.cpp
)
ENDIF ()
ENDIF ()
FOREACH (source_file ${exec_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()
FOREACH (source_file ${with_pthread_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
Threads::Threads
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()
FOREACH (source_file ${with_boost_lib_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
Boost::timer
)
IF (NOT MSVC AND NOT APPLE)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
rt
)
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -O3")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()

104
example/cpp03/class_intrusive.cpp
View File

@ -1,104 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cassert>
// When you want to adapt map instead of array, you can enable these macro definition.
//
// #define MSGPACK_USE_DEFINE_MAP
#include <msgpack.hpp>
struct my_base1 {
int a;
MSGPACK_DEFINE(a);
};
inline bool operator==(my_base1 const& lhs, my_base1 const& rhs) {
return lhs.a == rhs.a;
}
struct my_base2 {
std::string b;
std::string c;
MSGPACK_DEFINE(b, c);
};
inline bool operator==(my_base2 const& lhs, my_base2 const& rhs) {
return lhs.b == rhs.b && lhs.c == rhs.c;
}
class my_class : public my_base1, private my_base2 {
public:
my_class() {} // When you want to convert from msgpack::object to my_class,
// my_class should be default constractible.
my_class(std::string const& name, int age):name_(name), age_(age) {}
void set_b(std::string const& str) { b = str; }
void set_c(std::string const& str) { c = str; }
friend bool operator==(my_class const& lhs, my_class const& rhs) {
return
static_cast<my_base1 const&>(lhs) == static_cast<my_base1 const&>(rhs) &&
static_cast<my_base2 const&>(lhs) == static_cast<my_base2 const&>(rhs) &&
lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
}
private:
std::string name_;
int age_;
public:
MSGPACK_DEFINE(name_, age_, MSGPACK_BASE(my_base1), MSGPACK_BASE(my_base2));
};
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
{ // pack, unpack
my_class my("John Smith", 42);
my.a = 123;
my.set_b("ABC");
my.set_c("DEF");
std::stringstream ss;
msgpack::pack(ss, my);
std::string const& str = ss.str();
print(str);
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::object obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
{ // create object with zone
my_class my("John Smith", 42);
my.a = 123;
my.set_b("ABC");
my.set_c("DEF");
msgpack::zone z;
msgpack::object obj(my, z);
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
}

76
example/cpp03/class_intrusive_map.cpp
View File

@ -1,76 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cassert>
#include <msgpack.hpp>
class my_class {
public:
my_class() {} // When you want to convert from msgpack::object to my_class,
// my_class should be default constractible.
// If you use C++11, you can adapt non-default constructible
// classes to msgpack::object.
// See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_adaptor#non-default-constructible-class-support-c11-only
my_class(std::string const& name, int age):name_(name), age_(age) {}
friend bool operator==(my_class const& lhs, my_class const& rhs) {
return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
}
private:
std::string name_;
int age_;
public:
MSGPACK_DEFINE_MAP(name_, age_);
};
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
{ // pack, unpack
my_class my("John Smith", 42);
std::stringstream ss;
msgpack::pack(ss, my);
print(ss.str());
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::object obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
{ // create object with zone
my_class my("John Smith", 42);
msgpack::zone z;
msgpack::object obj(my, z);
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
}

119
example/cpp03/class_non_intrusive.cpp
View File

@ -1,119 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cassert>
#include <msgpack.hpp>
class my_class {
public:
my_class() {} // When you want to convert from msgpack::object to my_class,
// my_class should be default constractible.
my_class(std::string const& name, int age):name_(name), age_(age) {}
// my_class should provide getters for the data members you want to pack.
std::string const& get_name() const { return name_; }
int get_age() const { return age_; }
friend bool operator==(my_class const& lhs, my_class const& rhs) {
return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
}
private:
std::string name_;
int age_;
};
// User defined class template specialization
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template<>
struct convert<my_class> {
msgpack::object const& operator()(msgpack::object const& o, my_class& v) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 2) throw msgpack::type_error();
v = my_class(
o.via.array.ptr[0].as<std::string>(),
o.via.array.ptr[1].as<int>());
return o;
}
};
template<>
struct pack<my_class> {
template <typename Stream>
packer<Stream>& operator()(msgpack::packer<Stream>& o, my_class const& v) const {
// packing member variables as an array.
o.pack_array(2);
o.pack(v.get_name());
o.pack(v.get_age());
return o;
}
};
template <>
struct object_with_zone<my_class> {
void operator()(msgpack::object::with_zone& o, my_class const& v) const {
o.type = type::ARRAY;
o.via.array.size = 2;
o.via.array.ptr = static_cast<msgpack::object*>(
o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
}
};
} // namespace adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // namespace msgpack
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
{ // pack, unpack
my_class my("John Smith", 42);
std::stringstream ss;
msgpack::pack(ss, my);
std::string const& str = ss.str();
print(str);
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::object obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
{ // create object with zone
my_class my("John Smith", 42);
msgpack::zone z;
msgpack::object obj(my, z);
std::cout << obj << std::endl;
assert(obj.as<my_class>() == my);
}
}

67
example/cpp03/custom.cpp
View File

@ -1,67 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <msgpack.hpp>
#include <sstream>
#include <string>
#include <iostream>
class old_class {
public:
old_class() : value("default") { }
std::string value;
MSGPACK_DEFINE(value);
};
class new_class {
public:
new_class() : value("default"), flag(-1) { }
std::string value;
int flag;
MSGPACK_DEFINE(value, flag);
};
int main(void)
{
{
old_class oc;
new_class nc;
std::stringstream sbuf;
msgpack::pack(sbuf, oc);
msgpack::object_handle oh =
msgpack::unpack(sbuf.str().data(), sbuf.str().size());
msgpack::object obj = oh.get();
obj.convert(nc);
std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
}
{
new_class nc;
old_class oc;
std::stringstream sbuf;
msgpack::pack(sbuf, nc);
msgpack::object_handle oh =
msgpack::unpack(sbuf.str().data(), sbuf.str().size());
msgpack::object obj = oh.get();
obj.convert(oc);
std::cout << obj << " value=" << oc.value << std::endl;
}
}

59
example/cpp03/enum.cpp
View File

@ -1,59 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <sstream>
#include <iostream>
#include <cassert>
#include <msgpack.hpp>
enum my_enum {
elem1,
elem2,
elem3
};
MSGPACK_ADD_ENUM(my_enum);
int main(void)
{
{ // pack, unpack
std::stringstream sbuf;
msgpack::pack(sbuf, elem1);
msgpack::pack(sbuf, elem2);
my_enum e3 = elem3;
msgpack::pack(sbuf, e3);
msgpack::object_handle oh;
std::size_t off = 0;
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << oh.get().as<my_enum>() << std::endl;
assert(oh.get().as<my_enum>() == elem1);
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << oh.get().as<my_enum>() << std::endl;
assert(oh.get().as<my_enum>() == elem2);
msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << oh.get().as<my_enum>() << std::endl;
assert(oh.get().as<my_enum>() == elem3);
}
{ // create object without zone
msgpack::object obj(elem2);
std::cout << obj.as<my_enum>() << std::endl;
assert(obj.as<my_enum>() == elem2);
}
{ // create object with zone
msgpack::zone z;
msgpack::object objz(elem3, z);
std::cout << objz.as<my_enum>() << std::endl;
assert(objz.as<my_enum>() == elem3);
}
}

112
example/cpp03/map_based_versionup.cpp
View File

@ -1,112 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cassert>
#include <msgpack.hpp>
struct base1 {
base1():a("default") {}
std::string a;
MSGPACK_DEFINE_MAP(a);
};
struct v1 : base1 {
v1():name("default"), age(0) {}
std::string name;
int age;
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base1), name, age);
};
struct base2 {
base2():a("default") {}
std::string a;
MSGPACK_DEFINE_MAP(a);
};
// Removed: base1, name
// Added : base2, address
struct v2 : base2 {
v2(): age(0), address("default") {}
int age;
std::string address;
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base2), age, address);
};
// The member variable "age" is in common between v1 and v2.
void print(std::string const& buf) {
for (std::string::const_iterator it = buf.begin(), end = buf.end();
it != end;
++it) {
std::cout
<< std::setw(2)
<< std::hex
<< std::setfill('0')
<< (static_cast<int>(*it) & 0xff)
<< ' ';
}
std::cout << std::dec << std::endl;
}
int main() {
{ // pack v1, unpack, convert to v2
v1 v;
v.a = "ABC";
v.name = "John Smith";
v.age = 35;
std::stringstream ss;
msgpack::pack(ss, v);
print(ss.str());
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
msgpack::object obj = oh.get();
std::cout << obj << std::endl;
v2 newv = obj.as<v2>();
std::cout << "v2::a " << newv.a << std::endl;
std::cout << "v2::age " << newv.age << std::endl;
std::cout << "v2::address " << newv.address << std::endl;
// "age" is set from v1
assert(newv.a == "default");
assert(newv.age == 35);
assert(newv.address == "default");
}
{ // create v2 object with zone, convert to v1
v2 v;
v.a = "DEF";
v.age = 42;
v.address = "Tokyo";
msgpack::zone z;
msgpack::object obj(v, z);
std::cout << obj << std::endl;
v1 newv = obj.as<v1>();
std::cout << "v1::a " << newv.a << std::endl;
std::cout << "v1::name " << newv.name << std::endl;
std::cout << "v1::age " << newv.age << std::endl;
// "age" is set from v2
assert(newv.a == "default");
assert(newv.name == "default");
assert(newv.age == 42);
}
}

97
example/cpp03/protocol.cpp
View File

@ -1,97 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
// This example uses obsolete APIs
// See protocol_new.cpp
namespace myprotocol {
using namespace msgpack::type;
using msgpack::define;
struct Get : define< tuple<uint32_t, std::string> > {
Get() { }
Get(uint32_t f, const std::string& k) :
define_type(msgpack_type(f, k)) { }
uint32_t& flags() { return msgpack::type::get<0>(*this); }
std::string& key() { return msgpack::type::get<1>(*this); }
};
struct Put : define< tuple<uint32_t, std::string, raw_ref> > {
Put() { }
Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) :
define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { }
uint32_t& flags() { return msgpack::type::get<0>(*this); }
std::string& key() { return msgpack::type::get<1>(*this); }
raw_ref& value() { return msgpack::type::get<2>(*this); }
};
struct MultiGet : define< std::vector<Get> > {
};
}
int main(void)
{
// send Get request
std::stringstream stream;
{
myprotocol::Get req;
req.flags() = 0;
req.key() = "key0";
msgpack::pack(stream, req);
}
stream.seekg(0);
// receive Get request
{
std::string buffer(stream.str());
msgpack::object_handle oh =
msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = oh.get();
myprotocol::Get req;
o.convert(req);
std::cout << "received: " << o << std::endl;
}
stream.str("");
// send MultiGet request
{
myprotocol::MultiGet req;
req.push_back( myprotocol::Get(1, "key1") );
req.push_back( myprotocol::Get(2, "key2") );
req.push_back( myprotocol::Get(3, "key3") );
msgpack::pack(stream, req);
}
stream.seekg(0);
// receive MultiGet request
{
std::string buffer(stream.str());
msgpack::object_handle oh =
msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = oh.get();
myprotocol::MultiGet req;
o.convert(req);
std::cout << "received: " << o << std::endl;
}
}

84
example/cpp03/protocol_new.cpp
View File

@ -1,84 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
// This example uses obsolete APIs
// See protocol_new.cpp
namespace myprotocol {
struct Get {
Get() {}
Get(uint32_t f, const std::string& k) : flags(f), key(k) {}
uint32_t flags;
std::string key;
MSGPACK_DEFINE(flags, key);
};
typedef std::vector<Get> MultiGet;
}
int main(void)
{
// send Get request
std::stringstream stream;
{
myprotocol::Get req;
req.flags = 0;
req.key = "key0";
msgpack::pack(stream, req);
}
stream.seekg(0);
// receive Get request
{
std::string buffer(stream.str());
msgpack::object_handle oh =
msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = oh.get();
myprotocol::Get req;
o.convert(req);
std::cout << "received: " << o << std::endl;
}
stream.str("");
// send MultiGet request
{
myprotocol::MultiGet req;
req.push_back( myprotocol::Get(1, "key1") );
req.push_back( myprotocol::Get(2, "key2") );
req.push_back( myprotocol::Get(3, "key3") );
msgpack::pack(stream, req);
}
stream.seekg(0);
// receive MultiGet request
{
std::string buffer(stream.str());
msgpack::object_handle oh =
msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = oh.get();
myprotocol::MultiGet req;
o.convert(req);
std::cout << "received: " << o << std::endl;
}
}

43
example/cpp03/reuse_zone.cpp
View File

@ -1,43 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <sstream>
#include <cassert>
#include <string>
#include <vector>
#include <msgpack.hpp>
int main() {
std::vector<int> v;
v.push_back(1);
v.push_back(42);
std::string s("ABC");
std::stringstream ss;
msgpack::pack(ss, v);
msgpack::pack(ss, s);
msgpack::zone z;
std::size_t offset = 0;
// msgpack array is constructed on z.
std::string const& ps = ss.str();
msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset);
std::cout << obj << std::endl;
assert(obj.as<std::vector<int> >() == v);
// msgpack str is constructed on z.
std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as<std::string>();
std::cout << str << std::endl;
assert(str == s);
}

44
example/cpp03/simple.cpp
View File

@ -1,44 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
int main(void)
{
msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
// serialize the object into the buffer.
// any classes that implements write(const char*,size_t) can be a buffer.
std::stringstream buffer;
msgpack::pack(buffer, src);
// send the buffer ...
buffer.seekg(0);
// deserialize the buffer into msgpack::object instance.
std::string str(buffer.str());
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
// deserialized object is valid during the msgpack::object_handle instance alive.
msgpack::object deserialized = oh.get();
// msgpack::object supports ostream.
std::cout << deserialized << std::endl;
// convert msgpack::object instance into the original type.
// if the type is mismatched, it throws msgpack::type_error exception.
msgpack::type::tuple<int, bool, std::string> dst;
deserialized.convert(dst);
return 0;
}

63
example/cpp03/speed_test.cpp
View File

@ -1,63 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2013-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
// export LD_LIBRARY_PATH=path_to_boost_lib
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <boost/timer/timer.hpp>
void test_map_pack_unpack() {
std::cout << "[TEST][map_pack_unpack]" << std::endl;
// setup
std::cout << "Setting up map data..." << std::endl;
std::map<int, int> m1;
int const num = 30000000L;
for (int i = 0; i < num; ++i) m1[i] = i;
std::cout << "Start packing..." << std::endl;
std::stringstream buffer;
{
boost::timer::cpu_timer timer;
msgpack::pack(buffer, m1);
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Pack finished..." << std::endl;
buffer.seekg(0);
std::string str(buffer.str());
msgpack::object_handle oh;
std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
{
boost::timer::cpu_timer timer;
msgpack::unpack(oh, str.data(), str.size());
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Unpack finished..." << std::endl;
std::map<int, int> m2;
std::cout << "Start converting..." << std::endl;
{
boost::timer::cpu_timer timer;
oh.get().convert(m2);
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Convert finished..." << std::endl;
}
int main(void)
{
test_map_pack_unpack();
}

86
example/cpp03/speed_test_nested_array.cpp
View File

@ -1,86 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2013-2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
// export LD_LIBRARY_PATH=path_to_boost_lib
#include <msgpack.hpp>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <boost/timer/timer.hpp>
template <typename T, std::size_t level>
struct vecvec {
typedef std::vector<typename vecvec<T, level - 1>::type> type;
static void fill(type& v, std::size_t num_of_elems, T const& val) {
for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
typename vecvec<T, level - 1>::type child;
vecvec<T, level - 1>::fill(child, num_of_elems, val);
v.push_back(child);
}
}
};
template <typename T>
struct vecvec<T, 0> {
typedef std::vector<T> type;
static void fill(type& v, std::size_t num_of_elems, T const& val) {
for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
v.push_back(val);
}
}
};
void test_array_of_array() {
std::cout << "[TEST][array_of_array]" << std::endl;
// setup
int const depth = 4;
std::cout << "Setting up array data..." << std::endl;
vecvec<int, depth>::type v1;
vecvec<int, depth>::fill(v1, 3, 42);
std::cout << "Start packing..." << std::endl;
std::stringstream buffer;
{
boost::timer::cpu_timer timer;
msgpack::pack(buffer, v1);
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Pack finished..." << std::endl;
buffer.seekg(0);
std::string str(buffer.str());
msgpack::object_handle oh;
std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
{
boost::timer::cpu_timer timer;
msgpack::unpack(oh, str.data(), str.size());
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Unpack finished..." << std::endl;
vecvec<int, depth>::type v2;
std::cout << "Start converting..." << std::endl;
{
boost::timer::cpu_timer timer;
oh.get().convert(v2);
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Convert finished..." << std::endl;
}
int main(void)
{
test_array_of_array();
}

148
example/cpp03/stream.cpp
View File

@ -1,148 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <msgpack.hpp>
#include <iostream>
#include <stdexcept>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#if defined(_MSC_VER) || defined(__MINGW32__)
#include <io.h>
#include <fcntl.h>
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
#endif // _MSC_VER || __MINGW32__
class Server {
public:
Server(int sock) : m_sock(sock) { }
~Server() { }
typedef msgpack::unique_ptr<msgpack::zone> unique_zone;
void socket_readable()
{
m_pac.reserve_buffer(1024);
ssize_t count =
read(m_sock, m_pac.buffer(), m_pac.buffer_capacity());
if(count <= 0) {
if(count == 0) {
throw std::runtime_error("connection closed");
}
if(errno == EAGAIN || errno == EINTR) {
return;
}
throw std::runtime_error(strerror(errno));
}
m_pac.buffer_consumed(count);
msgpack::object_handle oh;
while (m_pac.next(oh)) {
msgpack::object msg = oh.get();
unique_zone& life = oh.zone();
process_message(msg, life);
}
if(m_pac.message_size() > 10*1024*1024) {
throw std::runtime_error("message is too large");
}
}
private:
void process_message(msgpack::object msg, unique_zone&)
{
std::cout << "message reached: " << msg << std::endl;
}
private:
int m_sock;
msgpack::unpacker m_pac;
};
static void* run_server(void* arg)
{
try {
Server* srv = reinterpret_cast<Server*>(arg);
while(true) {
srv->socket_readable();
}
return NULL;
} catch (std::exception& e) {
std::cerr << "error while processing client packet: "
<< e.what() << std::endl;
return NULL;
} catch (...) {
std::cerr << "error while processing client packet: "
<< "unknown error" << std::endl;
return NULL;
}
}
struct fwriter {
fwriter(int fd) : m_fp( fdopen(fd, "w") ) { }
void write(const char* buf, size_t buflen)
{
size_t count = fwrite(buf, buflen, 1, m_fp);
if(count < 1) {
std::cout << buflen << std::endl;
std::cout << count << std::endl;
throw std::runtime_error(strerror(errno));
}
}
void flush() { fflush(m_fp); }
void close() { fclose(m_fp); }
private:
FILE* m_fp;
};
int main(void)
{
int pair[2];
if (pipe(pair) != 0) return -1;
// run server thread
Server srv(pair[0]);
pthread_t thread;
pthread_create(&thread, NULL,
run_server, reinterpret_cast<void*>(&srv));
// client thread:
fwriter writer(pair[1]);
msgpack::packer<fwriter> pk(writer);
typedef msgpack::type::tuple<std::string, std::string, std::string> put_t;
typedef msgpack::type::tuple<std::string, std::string> get_t;
put_t req1("put", "apple", "red");
put_t req2("put", "lemon", "yellow");
get_t req3("get", "apple");
pk.pack(req1);
pk.pack(req2);
pk.pack(req3);
writer.flush();
writer.close();
pthread_join(thread, NULL);
}

38
example/cpp11/CMakeLists.txt
View File

@ -1,38 +0,0 @@
IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17)
LIST (APPEND exec_PROGRAMS
container.cpp
non_def_con_class.cpp
)
IF ("${MSGPACK_DEFAULT_API_VERSION}" GREATER "1")
LIST (APPEND exec_PROGRAMS
socket_stream_example.cpp
)
ENDIF ()
FOREACH (source_file ${exec_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()
ENDIF ()

159
example/cpp11/container.cpp
View File

@ -1,159 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <sstream>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <forward_list>
#include <string>
#include <msgpack.hpp>
void array() {
std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
std::stringstream ss;
msgpack::pack(ss, a);
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size());
auto obj = oh.get();
std::cout << obj << std::endl;
assert((obj.as<std::array<int, 5>>()) == a);
}
void tuple() {
std::tuple<bool, std::string, int> t(true, "ABC", 42);
std::stringstream ss;
msgpack::pack(ss, t);
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size());
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(t)>() == t);
}
void unordered_map() {
std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
std::stringstream ss;
msgpack::pack(ss, m);
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size());
msgpack::object obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(m)>() == m);
}
void unordered_set() {
std::unordered_set<std::string> s { "ABC", "DEF" };
std::stringstream ss;
msgpack::pack(ss, s);
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size());
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(s)>() == s);
}
void forward_list() {
using type = std::forward_list<std::string>;
type f { "ABC", "DEF" };
std::stringstream ss;
msgpack::pack(ss, f);
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size());
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<type>() == f);
}
void combi() {
std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
std::tuple<bool, std::string, int> t {true, "ABC", 42};
std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
std::unordered_set<std::string> s { "ABC", "DEF" };
std::forward_list<std::string> f { "ABC", "DEF" };
std::stringstream ss;
msgpack::pack(ss, a);
msgpack::pack(ss, t);
msgpack::pack(ss, m);
msgpack::pack(ss, s);
msgpack::pack(ss, f);
std::size_t offset = 0;
std::cout << "offset: " << offset << std::endl;
{
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size(), offset);
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(a)>() == a);
}
std::cout << "offset: " << offset << std::endl;
{
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size(), offset);
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(t)>() == t);
}
std::cout << "offset: " << offset << std::endl;
{
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size(), offset);
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(m)>() == m);
}
std::cout << "offset: " << offset << std::endl;
{
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size(), offset);
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(s)>() == s);
}
std::cout << "offset: " << offset << std::endl;
{
auto const& str = ss.str();
auto oh = msgpack::unpack(str.data(), str.size(), offset);
auto obj = oh.get();
std::cout << obj << std::endl;
assert(obj.as<decltype(f)>() == f);
}
std::cout << "offset: " << offset << std::endl;
}
int main() {
array();
tuple();
unordered_map();
unordered_set();
forward_list();
combi();
}

51
example/cpp11/non_def_con_class.cpp
View File

@ -1,51 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <cassert>
#include <memory>
#include <iostream>
#include <msgpack.hpp>
struct my {
my() = delete;
// target class should be either copyable or movable (or both).
my(my const&) = delete;
my(my&&) = default;
my(int a):a(a) {}
int a;
MSGPACK_DEFINE(a);
};
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template<>
struct as<my> {
my operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return my(o.via.array.ptr[0].as<int>());
}
};
} // namespace adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // namespace msgpack
int main() {
my m1(42);
msgpack::zone z;
msgpack::object obj(m1, z);
std::cout << obj << std::endl;
assert(m1.a == obj.as<my>().a);
}

157
example/cpp11/socket_stream_example.cpp
View File

@ -1,157 +0,0 @@
#include <iostream>
#include <sstream>
#include <msgpack.hpp>
struct json_like_visitor : msgpack::v2::null_visitor {
json_like_visitor(std::string& s):m_s(s), m_ref(false) {} // m_ref is false by default
bool visit_nil() {
m_s += "null";
return true;
}
bool visit_boolean(bool v) {
if (v) m_s += "true";
else m_s += "false";
return true;
}
bool visit_positive_integer(uint64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_negative_integer(int64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_str(const char* v, uint32_t size) {
// I omit escape process.
m_s += '"' + std::string(v, size) + '"';
return true;
}
bool start_array(uint32_t /*num_elements*/) {
m_s += "[";
return true;
}
bool end_array_item() {
m_s += ",";
return true;
}
bool end_array() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "]";
return true;
}
bool start_map(uint32_t /*num_kv_pairs*/) {
m_s += "{";
return true;
}
bool end_map_key() {
m_s += ":";
return true;
}
bool end_map_value() {
m_s += ",";
return true;
}
bool end_map() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "}";
return true;
}
void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
std::cerr << "parse error"<<std::endl;
}
void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
std::cout << "insufficient bytes"<<std::endl;
}
std::string& m_s;
// These two functions are required by parser.
void set_referenced(bool ref) { m_ref = ref; }
bool referenced() const { return m_ref; }
bool m_ref;
};
struct do_nothing {
void operator()(char* /*buffer*/) {
}
};
class json_like_printer : public msgpack::parser<json_like_printer, do_nothing>,
public json_like_visitor {
typedef parser<json_like_printer, do_nothing> parser_t;
public:
json_like_printer(std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE)
:parser_t(do_nothing_, initial_buffer_size),
json_like_visitor(json_str_) {
}
json_like_visitor& visitor() { return *this; }
void print() { std::cout << json_str_ << std::endl; json_str_.clear();}
private:
do_nothing do_nothing_;
std::string json_str_;
};
template <typename T>
struct ref_buffer {
ref_buffer(T& t):t(t) {}
void write(char const* ptr, std::size_t len) {
if (len > t.buffer_capacity()) {
t.reserve_buffer(len - t.buffer_capacity());
}
std::memcpy(t.buffer(), ptr, len);
t.buffer_consumed(len);
}
T& t;
};
#define BUFFERING_SIZE_MAX 100
//simulates streamed content (a socket for example)
bool produce( std::stringstream & ss, char* buff, std::size_t& size)
{
ss.read(buff, BUFFERING_SIZE_MAX);
size = static_cast<std::size_t>(ss.gcount());
return (size > 0);
}
//shows how you can treat data
void consume( const char* buff, const std::size_t size,
ref_buffer<json_like_printer> & rb,
json_like_printer & jp
)
{
rb.write(buff,size);
while( jp.next() )
{
//here we print the data, you could do any wanted processing
jp.print();
}
}
int main() {
std::vector<std::vector<int>> vvi1 { { 1,2,3,4,5}, { 6,7,8,9,10} };
std::vector<std::vector<int>> vvi2 { { 11,12,13,14,15}, { 16,17,18,19,20} };
std::stringstream ss;
msgpack::pack(ss, vvi1);
msgpack::pack(ss, vvi2);
char buffer[BUFFERING_SIZE_MAX];
std::size_t size = 0;
json_like_printer jp(1); // set initial buffer size explicitly
ref_buffer<json_like_printer> rb(jp);
while( produce(ss,buffer,size) )
{
consume(buffer, size, rb, jp);
}
}

63
example/x3/CMakeLists.txt
View File

@ -1,63 +0,0 @@
IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
FIND_PACKAGE (Boost REQUIRED COMPONENTS context)
FIND_PACKAGE (Threads REQUIRED)
LIST (APPEND exec_PROGRAMS
unpack.cpp
parse.cpp
)
LIST (APPEND with_boost_PROGRAMS
stream_unpack.cpp
)
FOREACH (source_file ${exec_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpack-cxx)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()
FOREACH (source_file ${with_boost_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpack-cxx
Boost::context
Threads::Threads
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
ENDIF ()
ENDFOREACH ()
ENDIF ()

125
example/x3/parse.cpp
View File

@ -1,125 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <sstream>
#include <cassert>
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
#include <msgpack.hpp>
struct json_like_visitor : msgpack::v2::null_visitor {
json_like_visitor(std::string& s):m_s(s) {}
bool visit_nil() {
m_s += "null";
return true;
}
bool visit_boolean(bool v) {
if (v) m_s += "true";
else m_s += "false";
return true;
}
bool visit_positive_integer(uint64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_negative_integer(int64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_float32(float v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_float64(double v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_str(const char* v, uint32_t size) {
m_s += '"' + std::string(v, size) + '"';
return true;
}
bool start_array(uint32_t /*num_elements*/) {
m_s += "[";
return true;
}
bool end_array_item() {
m_s += ",";
return true;
}
bool end_array() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "]";
return true;
}
bool start_map(uint32_t /*num_kv_pairs*/) {
m_s += "{";
return true;
}
bool end_map_key() {
m_s += ":";
return true;
}
bool end_map_value() {
m_s += ",";
return true;
}
bool end_map() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "}";
return true;
}
void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
}
void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
}
std::string& m_s;
};
int main() {
std::stringstream ss;
std::map<std::string, std::vector<int>> v1 {
{ "ABC", { 1, 2, 3 } },
{ "DEFG", { 4, 5 } }
};
std::vector<std::string> v2 {
"HIJ", "KLM", "NOP"
};
msgpack::pack(ss, v1);
msgpack::pack(ss, v2);
std::string const& buf = ss.str();
auto it = buf.begin();
auto end = buf.end();
{
std::string str;
bool ret = msgpack::parse(it, end, json_like_visitor(str));
// it is updated here.
assert(ret);
std::cout << str << std::endl;
}
{
std::string str;
bool ret = msgpack::parse(it, end, json_like_visitor(str));
// it is updated here.
assert(ret);
std::cout << str << std::endl;
}
}

248
example/x3/stream_unpack.cpp
View File

@ -1,248 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <sstream>
#include <cassert>
#include <thread>
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
//#define MSGPACK_USE_X3_PARSE
#include <msgpack.hpp>
#include <boost/asio.hpp>
#include <boost/coroutine2/all.hpp>
#if defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif // defined(__clang__)
#include <boost/spirit/home/support/multi_pass.hpp>
#if defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__clang__)
namespace as = boost::asio;
namespace x3 = boost::spirit::x3;
namespace coro2 = boost::coroutines2;
using pull_type = coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::pull_type;
// iterator fetching data from coroutine2.
class buffered_iterator : public std::iterator<std::input_iterator_tag, char> {
public:
using pointer_t = typename iterator::pointer;
using reference_t = typename iterator::reference;
explicit buffered_iterator(pull_type& source) noexcept
: source_{ &source } {
fetch_();
}
buffered_iterator() = default;
bool operator==(buffered_iterator const& other) const noexcept {
if (!other.source_ && !source_ && !other.buf_ && !buf_) return true;
return other.it_ == it_;
}
bool operator!=(buffered_iterator const& other) const noexcept {
return !(other == *this);
}
buffered_iterator & operator++() {
increment_();
return * this;
}
buffered_iterator operator++(int) = delete;
reference_t operator*() noexcept {
return *it_;
}
pointer_t operator->() noexcept {
return std::addressof(*it_);
}
private:
void fetch_() noexcept {
BOOST_ASSERT( nullptr != source_);
if (*source_) {
buf_ = source_->get();
it_ = buf_->begin();
}
else {
source_ = nullptr;
buf_.reset();
}
}
void increment_() {
BOOST_ASSERT( nullptr != source_);
BOOST_ASSERT(*source_);
if (++it_ == buf_->end()) {
(*source_)();
fetch_();
}
}
private:
pull_type* source_{ nullptr };
std::shared_ptr<std::vector<char>> buf_;
std::vector<char>::iterator it_;
};
// session class that corresponding to each client
class session : public std::enable_shared_from_this<session> {
public:
session(as::ip::tcp::socket socket)
: socket_(std::move(socket)) {
}
void start() {
sink_ = std::make_shared<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type>(
[&, this](pull_type& source) {
// *1 is started when the first sink is called.
std::cout << "session started" << std::endl;
do_read();
source();
// use buffered_iterator here
// b is incremented in msgpack::unpack() and fetch data from sink
// via coroutine2 mechanism
auto b = boost::spirit::make_default_multi_pass(buffered_iterator(source));
auto e = boost::spirit::make_default_multi_pass(buffered_iterator());
// This is usually an infinity look, but for test, loop is finished when
// two message pack data is processed.
for (int i = 0; i != 2; ++i) {
auto oh = msgpack::unpack(b, e);
std::cout << oh.get() << std::endl;
}
}
);
// send dummy data to start *1
(*sink_)({});
}
private:
void do_read() {
std::cout << "session do_read() is called" << std::endl;
auto self(shared_from_this());
auto data = std::make_shared<std::vector<char>>(static_cast<std::size_t>(max_length));
socket_.async_read_some(
boost::asio::buffer(*data),
[this, self, data]
(boost::system::error_code ec, std::size_t length) {
if (!ec) {
data->resize(length);
(*sink_)(data);
do_read();
}
}
);
}
as::ip::tcp::socket socket_;
static constexpr std::size_t const max_length = 1024;
std::shared_ptr<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type> sink_;
};
class server {
public:
server(
as::io_service& ios,
std::uint16_t port)
: acceptor_(ios, as::ip::tcp::endpoint(as::ip::tcp::v4(), port)),
socket_(ios) {
do_accept();
std::cout << "server start accept" << std::endl;
ios.run();
}
private:
void do_accept() {
acceptor_.async_accept(
socket_,
[this](boost::system::error_code ec) {
if (!ec) {
std::make_shared<session>(std::move(socket_))->start();
}
// for test, only one session is accepted.
// do_accept();
}
);
}
as::ip::tcp::acceptor acceptor_;
as::ip::tcp::socket socket_;
};
int main() {
std::thread srv(
[]{
boost::asio::io_service ios;
server s(ios, 12345);
}
);
std::thread cli(
[]{
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "client start" << std::endl;
std::stringstream ss;
std::map<std::string, std::vector<int>> v1 {
{ "ABC", { 1, 2, 3 } },
{ "DEFG", { 4, 5 } }
};
std::vector<std::string> v2 {
"HIJ", "KLM", "NOP"
};
msgpack::pack(ss, v1);
msgpack::pack(ss, v2);
auto send_data = ss.str();
boost::asio::io_service ios;
as::ip::tcp::resolver::query q("127.0.0.1", "12345");
as::ip::tcp::resolver r(ios);
auto it = r.resolve(q);
std::cout << "client connect" << std::endl;
as::ip::tcp::socket s(ios);
as::connect(s, it);
std::size_t const size = 5;
std::size_t rest = send_data.size();
std::size_t index = 0;
while (rest != 0) {
std::cout << "client send data" << std::endl;
auto send_size = size < rest ? size : rest;
as::write(s, as::buffer(&send_data[index], send_size));
rest -= send_size;
index += send_size;
std::cout << "client wait" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
);
cli.join();
std::cout << "client joinded" << std::endl;
srv.join();
std::cout << "server joinded" << std::endl;
}

43
example/x3/unpack.cpp
View File

@ -1,43 +0,0 @@
// MessagePack for C++ example
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <sstream>
#include <cassert>
// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
#include <msgpack.hpp>
int main() {
std::stringstream ss;
std::map<std::string, std::vector<int>> v1 {
{ "ABC", { 1, 2, 3 } },
{ "DEFG", { 4, 5 } }
};
std::vector<std::string> v2 {
"HIJ", "KLM", "NOP"
};
msgpack::pack(ss, v1);
msgpack::pack(ss, v2);
std::string const& buf = ss.str();
auto it = buf.begin();
auto end = buf.end();
{
auto oh = msgpack::unpack(it, end);
// it is updated here.
assert(v1 == (oh.get().as<std::map<std::string, std::vector<int>>>()));
}
{
auto oh = msgpack::unpack(it, end);
assert(v2 == oh.get().as<std::vector<std::string>>());
}
}

37
fuzz/CMakeLists.txt
View File

@ -1,37 +0,0 @@
FIND_PACKAGE (Threads REQUIRED)
FIND_PACKAGE (Boost REQUIRED COMPONENTS filesystem unit_test_framework)
LIST (APPEND check_PROGRAMS
regression_runner.cpp
)
FOREACH (source_file ${check_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
${source_file_we}
${source_file}
)
TARGET_COMPILE_DEFINITIONS (${source_file_we} PRIVATE
$<IF:$<BOOL:${MSGPACK_USE_STATIC_BOOST}>,,BOOST_TEST_DYN_LINK>)
TARGET_LINK_LIBRARIES (${source_file_we}
msgpack-cxx
Threads::Threads
Boost::filesystem
Boost::unit_test_framework
)
ADD_TEST (${source_file_we} ${source_file_we})
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -g")
IF ("${MSGPACK_SAN}" STREQUAL "ASAN")
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
ELSEIF ("${MSGPACK_SAN}" STREQUAL "UBSAN")
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
ENDIF()
ENDIF()
ENDFOREACH ()

49
fuzz/regression_runner.cpp
View File

@ -1,49 +0,0 @@
#include <boost/filesystem.hpp>
// Use parameterized tests instead of modern data-driven test cases
// because BOOST_DATA_TEST_CASE requires C++11 or newer. See:
// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/param_test.html
// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/test_case_generation.html
#include <boost/test/included/unit_test.hpp>
#include <boost/test/parameterized_test.hpp>
#include <fstream>
#include <string>
#include <vector>
#include "unpack_pack_fuzzer.cpp"
std::vector<std::string> ListDirectory(const std::string& path) {
std::vector<std::string> v;
boost::filesystem::path p(path);
boost::filesystem::directory_iterator f(p);
if (boost::filesystem::is_directory(p)) {
while (f != boost::filesystem::directory_iterator()) {
v.push_back((*f++).path().string());
}
}
return v;
}
void UnpackPackFuzzerRegressionTest(const std::string& fpath) {
std::ifstream in(fpath.c_str(), std::ios_base::binary);
if (!in) {
BOOST_FAIL(fpath + " not found");
}
in.seekg(0, in.end);
size_t length = in.tellg();
in.seekg(0, in.beg);
std::vector<char> bytes(length);
in.read(bytes.data(), bytes.size());
BOOST_REQUIRE(in);
BOOST_REQUIRE_EQUAL(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()), bytes.size()));
}
boost::unit_test::test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
{
std::vector<std::string> files = ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions");
boost::unit_test::framework::master_test_suite().add(BOOST_PARAM_TEST_CASE(&UnpackPackFuzzerRegressionTest, files.begin(), files.end()));
return 0;
}

27
fuzz/unpack_pack_fuzzer.cpp
View File

@ -1,27 +0,0 @@
#include <msgpack.hpp>
// The function's signature must NOT be changed since other projects rely on it:
// - libFuzzer
// - AFL++
// - Google's oss-fuzz (uses the previous two ones)
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
try {
// NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
// setting these at far smaller values to avoid OOMs
const int test_limit = 1000;
msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
size,
MSGPACK_NULLPTR,
MSGPACK_NULLPTR,
msgpack::unpack_limit(test_limit,
test_limit,
test_limit,
test_limit,
test_limit,
test_limit));
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, unpacked.get());
} catch (...) {
}
return 0;
}

BIN
fuzz/unpack_pack_fuzzer_regressions/clusterfuzz-testcase-minimized-unpack_pack_fuzzer-5656982724804608
View File

Binary file not shown.

BIN
fuzz/unpack_pack_fuzzer_regressions/clusterfuzz-testcase-minimized-unpack_pack_fuzzer-6022481354686464
View File

Binary file not shown.

1
fuzz/unpack_pack_fuzzer_seed_corpus/EmptyArray
View File

@ -1 +0,0 @@
<EFBFBD>

1
fuzz/unpack_pack_fuzzer_seed_corpus/EmptyObject
View File

@ -1 +0,0 @@
<EFBFBD>

2
fuzz/unpack_pack_fuzzer_seed_corpus/ExcessiveNesting
View File

@ -1,2 +0,0 @@
’’’’’’’’’ ’
’ ’ ’ ’’’’’’’’’’’’’’’’’’’ ’!’"’#’$’%’&’'’(’)’*’+’,’-’.’/’0’1’2’3’4’5’6’7’8’9’:’;’<’=’>’?’@’A’B’C’D’E’F’G’H’I’J’K’L’M’N’O’P’Q’R’S’T’U’V’W’X’Y’Z’[’\’]’^’_’`’a’b’c’d’e’f’g’h’i’j’k’l’m’n’o’p’q’r’s’t’u’v’w‘x

BIN
fuzz/unpack_pack_fuzzer_seed_corpus/OpenWeatherMap
View File

Binary file not shown.

BIN
fuzz/unpack_pack_fuzzer_seed_corpus/WeatherUnderground
View File

Binary file not shown.

22
include/msgpack.hpp
View File

@ -1,22 +0,0 @@
//
// MessagePack for C++
//
// Copyright (C) 2008-2009 FURUHASHI Sadayuki
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include "msgpack/object.hpp"
#include "msgpack/iterator.hpp"
#include "msgpack/zone.hpp"
#include "msgpack/pack.hpp"
#include "msgpack/null_visitor.hpp"
#include "msgpack/parse.hpp"
#include "msgpack/unpack.hpp"
#include "msgpack/x3_parse.hpp"
#include "msgpack/x3_unpack.hpp"
#include "msgpack/sbuffer.hpp"
#include "msgpack/vrefbuffer.hpp"
#include "msgpack/version.hpp"
#include "msgpack/type.hpp"

19
include/msgpack/adaptor/adaptor_base.hpp
View File

@ -1,19 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015-2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_ADAPTOR_BASE_HPP
#define MSGPACK_ADAPTOR_BASE_HPP
#include "msgpack/adaptor/adaptor_base_decl.hpp"
#include "msgpack/v1/adaptor/adaptor_base.hpp"
#include "msgpack/v2/adaptor/adaptor_base.hpp"
#include "msgpack/v3/adaptor/adaptor_base.hpp"
#endif // MSGPACK_ADAPTOR_BASE_HPP

17
include/msgpack/adaptor/adaptor_base_decl.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_ADAPTOR_BASE_DECL_HPP
#define MSGPACK_ADAPTOR_BASE_DECL_HPP
#include "msgpack/v1/adaptor/adaptor_base_decl.hpp"
#include "msgpack/v2/adaptor/adaptor_base_decl.hpp"
#include "msgpack/v3/adaptor/adaptor_base_decl.hpp"
#endif // MSGPACK_ADAPTOR_BASE_DECL_HPP

17
include/msgpack/adaptor/array_ref.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_ARRAY_REF_HPP
#define MSGPACK_TYPE_ARRAY_REF_HPP
#include "msgpack/adaptor/array_ref_decl.hpp"
#include "msgpack/v1/adaptor/array_ref.hpp"
#endif // MSGPACK_TYPE_ARRAY_REFL_HPP

17
include/msgpack/adaptor/array_ref_decl.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_ARRAY_REF_DECL_HPP
#define MSGPACK_TYPE_ARRAY_REF_DECL_HPP
#include "msgpack/v1/adaptor/array_ref_decl.hpp"
#include "msgpack/v2/adaptor/array_ref_decl.hpp"
#include "msgpack/v3/adaptor/array_ref_decl.hpp"
#endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP

15
include/msgpack/adaptor/bool.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOL_HPP
#define MSGPACK_TYPE_BOOL_HPP
#include "msgpack/v1/adaptor/bool.hpp"
#endif // MSGPACK_TYPE_BOOL_HPP

15
include/msgpack/adaptor/boost/fusion.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_FUSION_HPP
#define MSGPACK_TYPE_BOOST_FUSION_HPP
#include "msgpack/v1/adaptor/boost/fusion.hpp"
#endif // MSGPACK_TYPE_BOOST_FUSION_HPP

18
include/msgpack/adaptor/boost/msgpack_variant.hpp
View File

@ -1,18 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015-2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
#include "msgpack/adaptor/boost/msgpack_variant_decl.hpp"
#include "msgpack/v1/adaptor/boost/msgpack_variant.hpp"
//#include "msgpack/v2/adaptor/boost/msgpack_variant.hpp"
#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP

17
include/msgpack/adaptor/boost/msgpack_variant_decl.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
#include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp"
#include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp"
#include "msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp"
#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP

15
include/msgpack/adaptor/boost/optional.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP
#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
#include "msgpack/v1/adaptor/boost/optional.hpp"
#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP

15
include/msgpack/adaptor/boost/string_ref.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP
#define MSGPACK_TYPE_BOOST_STRING_REF_HPP
#include "msgpack/v1/adaptor/boost/string_ref.hpp"
#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP

15
include/msgpack/adaptor/boost/string_view.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
#define MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
#include "msgpack/v1/adaptor/boost/string_view.hpp"
#endif // MSGPACK_TYPE_BOOST_STRING_VIEW_HPP

15
include/msgpack/adaptor/carray.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CARRAY_HPP
#define MSGPACK_TYPE_CARRAY_HPP
#include "msgpack/v1/adaptor/carray.hpp"
#endif // MSGPACK_TYPE_CARRAY_HPP

15
include/msgpack/adaptor/char_ptr.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CHAR_PTR_HPP
#define MSGPACK_TYPE_CHAR_PTR_HPP
#include "msgpack/v1/adaptor/char_ptr.hpp"
#endif // MSGPACK_TYPE_CHAR_PTR_HPP

17
include/msgpack/adaptor/check_container_size.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015-2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP
#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
#include "msgpack/adaptor/check_container_size_decl.hpp"
#include "msgpack/v1/adaptor/check_container_size.hpp"
#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

17
include/msgpack/adaptor/check_container_size_decl.hpp
View File

@ -1,17 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP
#define MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP
#include "msgpack/v1/adaptor/check_container_size_decl.hpp"
#include "msgpack/v2/adaptor/check_container_size_decl.hpp"
#include "msgpack/v3/adaptor/check_container_size_decl.hpp"
#endif // MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP

15
include/msgpack/adaptor/complex.hpp
View File

@ -1,15 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2020 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_COMPLEX_HPP
#define MSGPACK_TYPE_COMPLEX_HPP
#include "msgpack/v1/adaptor/complex.hpp"
#endif // MSGPACK_TYPE_COMPLEX_HPP

16
include/msgpack/adaptor/cpp11/array.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_ARRAY_HPP
#define MSGPACK_TYPE_CPP11_ARRAY_HPP
#include "msgpack/v1/adaptor/cpp11/array.hpp"
#endif // MSGPACK_TYPE_CPP11_ARRAY_HPP

16
include/msgpack/adaptor/cpp11/array_char.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
#define MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
#include "msgpack/v1/adaptor/cpp11/array_char.hpp"
#endif // MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP

16
include/msgpack/adaptor/cpp11/array_unsigned_char.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
#define MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
#include "msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp"
#endif // MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP

16
include/msgpack/adaptor/cpp11/chrono.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_CHRONO_HPP
#define MSGPACK_TYPE_CPP11_CHRONO_HPP
#include "msgpack/v1/adaptor/cpp11/chrono.hpp"
#endif // MSGPACK_TYPE_CPP11_CHRONO_HPP

16
include/msgpack/adaptor/cpp11/forward_list.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP
#define MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP
#include "msgpack/v1/adaptor/cpp11/forward_list.hpp"
#endif // MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP

16
include/msgpack/adaptor/cpp11/reference_wrapper.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
#define MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
#include "msgpack/v1/adaptor/cpp11/reference_wrapper.hpp"
#endif // MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP

16
include/msgpack/adaptor/cpp11/shared_ptr.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
#define MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
#include "msgpack/v1/adaptor/cpp11/shared_ptr.hpp"
#endif // MSGPACK_TYPE_CPP11_SHARED_PTR_HPP

16
include/msgpack/adaptor/cpp11/timespec.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2019 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_TIMESPEC_HPP
#define MSGPACK_TYPE_CPP11_TIMESPEC_HPP
#include "msgpack/v1/adaptor/cpp11/timespec.hpp"
#endif // MSGPACK_TYPE_CPP11_TIMESPEC_HPP

16
include/msgpack/adaptor/cpp11/tuple.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_TUPLE_HPP
#define MSGPACK_TYPE_CPP11_TUPLE_HPP
#include "msgpack/v1/adaptor/cpp11/tuple.hpp"
#endif // MSGPACK_TYPE_CPP11_TUPLE_HPP

16
include/msgpack/adaptor/cpp11/unique_ptr.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
#define MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
#include "msgpack/v1/adaptor/cpp11/unique_ptr.hpp"
#endif // MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP

16
include/msgpack/adaptor/cpp11/unordered_map.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
#define MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
#include "msgpack/v1/adaptor/cpp11/unordered_map.hpp"
#endif // MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP

16
include/msgpack/adaptor/cpp11/unordered_set.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2016 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
#define MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
#include "msgpack/v1/adaptor/cpp11/unordered_set.hpp"
#endif // MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP

16
include/msgpack/adaptor/cpp17/array_byte.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
#define MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
#include "msgpack/v1/adaptor/cpp17/array_byte.hpp"
#endif // MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP

16
include/msgpack/adaptor/cpp17/byte.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2018 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_BYTE_HPP
#define MSGPACK_TYPE_CPP17_BYTE_HPP
#include "msgpack/v1/adaptor/cpp17/byte.hpp"
#endif // MSGPACK_TYPE_CPP17_BYTE_HPP

16
include/msgpack/adaptor/cpp17/carray_byte.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2018 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
#define MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
#include "msgpack/v1/adaptor/cpp17/carray_byte.hpp"
#endif // MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP

16
include/msgpack/adaptor/cpp17/optional.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_OPTIONAL_HPP
#define MSGPACK_TYPE_CPP17_OPTIONAL_HPP
#include "msgpack/v1/adaptor/cpp17/optional.hpp"
#endif // MSGPACK_TYPE_CPP17_OPTIONAL_HPP

16
include/msgpack/adaptor/cpp17/string_view.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2017 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
#define MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
#include "msgpack/v1/adaptor/cpp17/string_view.hpp"
#endif // MSGPACK_TYPE_CPP17_STRING_VIEW_HPP

16
include/msgpack/adaptor/cpp17/variant.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2023 Uy Ha
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_VARIANT_HPP
#define MSGPACK_TYPE_CPP17_VARIANT_HPP
#include "msgpack/v1/adaptor/cpp17/variant.hpp"
#endif // MSGPACK_TYPE_CPP17_VARIANT_HPP

16
include/msgpack/adaptor/cpp17/vector_byte.hpp
View File

@ -1,16 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2018 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
#define MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
#include "msgpack/v1/adaptor/cpp17/vector_byte.hpp"
#endif // MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP

Some files were not shown because too many files have changed in this diff Show More