├── .clang-format
├── .github
    └── workflows
    │   └── build.yml
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── LICENSE
├── README.md
├── benchmark
    ├── CMakeLists.txt
    ├── benchmark_log_10k_deserialize.cpp
    ├── benchmark_log_10k_serialize.cpp
    ├── benchmark_mesh_125k_deserialize.cpp
    ├── benchmark_mesh_125k_serialize.cpp
    ├── benchmark_minecraft_players_50_deserialize.cpp
    ├── benchmark_minecraft_players_50_serialize.cpp
    ├── log.h
    ├── mesh.h
    └── minecraft_save.h
├── benchmark_results.txt
├── clang_format.bash
├── cmake
    └── project-is-top-level.cmake
├── include
    └── alpaca
    │   ├── alpaca.h
    │   └── detail
    │       ├── aggregate_arity.h
    │       ├── crc32.h
    │       ├── endian.h
    │       ├── field_type.h
    │       ├── from_bytes.h
    │       ├── is_bitset.h
    │       ├── is_specialization.h
    │       ├── options.h
    │       ├── output_container.h
    │       ├── print_bytes.h
    │       ├── struct_nth_field.h
    │       ├── to_bytes.h
    │       ├── type_info.h
    │       ├── types
    │           ├── array.h
    │           ├── bitset.h
    │           ├── deque.h
    │           ├── duration.h
    │           ├── filesystem_path.h
    │           ├── glm_vector.h
    │           ├── list.h
    │           ├── map.h
    │           ├── optional.h
    │           ├── pair.h
    │           ├── set.h
    │           ├── string.h
    │           ├── tuple.h
    │           ├── unique_ptr.h
    │           ├── variant.h
    │           └── vector.h
    │       ├── variable_length_encoding.h
    │       └── variant_nth_field.h
├── packaging
    └── pkgconfig.pc.in
├── python
    ├── CMakeLists.txt
    ├── pyalpaca.cpp
    ├── python_deserialize_helper.h
    └── python_serialize_helper.h
├── samples
    ├── CMakeLists.txt
    ├── arrays_vectors_strings.cpp
    ├── chrono_duration.cpp
    ├── demo.cpp
    ├── fundamental_types.cpp
    ├── maps_and_sets.cpp
    ├── nested_structures.cpp
    ├── optional_values.cpp
    ├── pyalpaca_demo.py
    ├── time_t.cpp
    ├── unique_ptr.cpp
    ├── variant.cpp
    └── write_file.cpp
└── test
    ├── CMakeLists.txt
    ├── doctest.hpp
    ├── main.cpp
    ├── test_backwards_compatibility.cpp
    ├── test_deserialize_array.cpp
    ├── test_deserialize_big_endian.cpp
    ├── test_deserialize_bool.cpp
    ├── test_deserialize_bool_from_array.cpp
    ├── test_deserialize_chrono_duration.cpp
    ├── test_deserialize_chrono_duration_from_array.cpp
    ├── test_deserialize_deque.cpp
    ├── test_deserialize_deque_from_array.cpp
    ├── test_deserialize_enum_class.cpp
    ├── test_deserialize_enum_class_from_array.cpp
    ├── test_deserialize_error_crc32.cpp
    ├── test_deserialize_error_crc32_from_array.cpp
    ├── test_deserialize_error_set.cpp
    ├── test_deserialize_error_set_from_array.cpp
    ├── test_deserialize_error_vector.cpp
    ├── test_deserialize_error_vector_from_array.cpp
    ├── test_deserialize_error_version.cpp
    ├── test_deserialize_error_version_from_array.cpp
    ├── test_deserialize_float.cpp
    ├── test_deserialize_float_from_array.cpp
    ├── test_deserialize_from_carray.cpp
    ├── test_deserialize_from_ifstream.cpp
    ├── test_deserialize_int.cpp
    ├── test_deserialize_int_from_array.cpp
    ├── test_deserialize_list.cpp
    ├── test_deserialize_list_from_array.cpp
    ├── test_deserialize_map.cpp
    ├── test_deserialize_map_from_array.cpp
    ├── test_deserialize_optional.cpp
    ├── test_deserialize_optional_from_array.cpp
    ├── test_deserialize_pair.cpp
    ├── test_deserialize_pair_from_array.cpp
    ├── test_deserialize_set.cpp
    ├── test_deserialize_set_from_array.cpp
    ├── test_deserialize_string.cpp
    ├── test_deserialize_string_from_array.cpp
    ├── test_deserialize_tuple.cpp
    ├── test_deserialize_tuple_from_array.cpp
    ├── test_deserialize_uint.cpp
    ├── test_deserialize_uint_from_array.cpp
    ├── test_deserialize_unique_ptr.cpp
    ├── test_deserialize_unique_ptr_from_array.cpp
    ├── test_deserialize_ustring.cpp
    ├── test_deserialize_variant.cpp
    ├── test_deserialize_variant_from_array.cpp
    ├── test_deserialize_vector.cpp
    ├── test_deserialize_vector_from_array.cpp
    ├── test_deserialize_with_crc32.cpp
    ├── test_deserialize_with_crc32_from_array.cpp
    ├── test_deserialize_with_version.cpp
    ├── test_deserialize_with_version_from_array.cpp
    ├── test_extended_serialize_deserialize.cpp
    ├── test_force_alignment.cpp
    ├── test_forwards_compatibility.cpp
    ├── test_forwards_compatibility_from_array.cpp
    ├── test_serialize_array.cpp
    ├── test_serialize_array_into_array.cpp
    ├── test_serialize_big_endian.cpp
    ├── test_serialize_big_endian_into_array.cpp
    ├── test_serialize_bool.cpp
    ├── test_serialize_bool_into_array.cpp
    ├── test_serialize_chrono_duration.cpp
    ├── test_serialize_chrono_duration_to_array.cpp
    ├── test_serialize_deque.cpp
    ├── test_serialize_deque_into_array.cpp
    ├── test_serialize_enum_class.cpp
    ├── test_serialize_enum_class_into_array.cpp
    ├── test_serialize_float.cpp
    ├── test_serialize_float_into_array.cpp
    ├── test_serialize_int.cpp
    ├── test_serialize_int_into_array.cpp
    ├── test_serialize_into_carray.cpp
    ├── test_serialize_list.cpp
    ├── test_serialize_list_into_array.cpp
    ├── test_serialize_map.cpp
    ├── test_serialize_map_into_array.cpp
    ├── test_serialize_nested_struct.cpp
    ├── test_serialize_nested_struct_into_array.cpp
    ├── test_serialize_optional.cpp
    ├── test_serialize_optional_into_array.cpp
    ├── test_serialize_pair.cpp
    ├── test_serialize_pair_optional.cpp
    ├── test_serialize_set.cpp
    ├── test_serialize_set_into_array.cpp
    ├── test_serialize_string.cpp
    ├── test_serialize_string_into_array.cpp
    ├── test_serialize_to_fstream.cpp
    ├── test_serialize_tuple.cpp
    ├── test_serialize_tuple_into_array.cpp
    ├── test_serialize_uint.cpp
    ├── test_serialize_uint_into_array.cpp
    ├── test_serialize_unique_ptr.cpp
    ├── test_serialize_unique_ptr_into_array.cpp
    ├── test_serialize_variant.cpp
    ├── test_serialize_variant_into_array.cpp
    ├── test_serialize_vector.cpp
    ├── test_serialize_vector_into_array.cpp
    ├── test_serialize_with_crc32.cpp
    ├── test_serialize_with_crc32_into_array.cpp
    └── test_type_info.cpp


/.clang-format:
--------------------------------------------------------------------------------
  1 | ---
  2 | Language:        Cpp
  3 | # BasedOnStyle:  LLVM
  4 | AccessModifierOffset: -2
  5 | AlignAfterOpenBracket: Align
  6 | AlignConsecutiveAssignments: false
  7 | AlignConsecutiveDeclarations: false
  8 | AlignEscapedNewlines: Right
  9 | AlignOperands:   true
 10 | AlignTrailingComments: true
 11 | AllowAllParametersOfDeclarationOnNextLine: true
 12 | AllowShortBlocksOnASingleLine: false
 13 | AllowShortCaseLabelsOnASingleLine: false
 14 | AllowShortFunctionsOnASingleLine: All
 15 | AllowShortIfStatementsOnASingleLine: false
 16 | AllowShortLoopsOnASingleLine: false
 17 | AlwaysBreakAfterDefinitionReturnType: None
 18 | AlwaysBreakAfterReturnType: None
 19 | AlwaysBreakBeforeMultilineStrings: false
 20 | AlwaysBreakTemplateDeclarations: false
 21 | BinPackArguments: true
 22 | BinPackParameters: true
 23 | BraceWrapping:   
 24 |   AfterClass:      false
 25 |   AfterControlStatement: false
 26 |   AfterEnum:       false
 27 |   AfterFunction:   false
 28 |   AfterNamespace:  false
 29 |   AfterObjCDeclaration: false
 30 |   AfterStruct:     false
 31 |   AfterUnion:      false
 32 |   AfterExternBlock: false
 33 |   BeforeCatch:     false
 34 |   BeforeElse:      false
 35 |   IndentBraces:    false
 36 |   SplitEmptyFunction: true
 37 |   SplitEmptyRecord: true
 38 |   SplitEmptyNamespace: true
 39 | BreakBeforeBinaryOperators: None
 40 | BreakBeforeBraces: Attach
 41 | BreakBeforeInheritanceComma: false
 42 | BreakBeforeTernaryOperators: true
 43 | BreakConstructorInitializersBeforeComma: false
 44 | BreakConstructorInitializers: BeforeColon
 45 | BreakAfterJavaFieldAnnotations: false
 46 | BreakStringLiterals: true
 47 | ColumnLimit:     80
 48 | CommentPragmas:  '^ IWYU pragma:'
 49 | CompactNamespaces: false
 50 | ConstructorInitializerAllOnOneLineOrOnePerLine: false
 51 | ConstructorInitializerIndentWidth: 4
 52 | ContinuationIndentWidth: 4
 53 | Cpp11BracedListStyle: true
 54 | DerivePointerAlignment: false
 55 | DisableFormat:   false
 56 | ExperimentalAutoDetectBinPacking: false
 57 | FixNamespaceComments: true
 58 | ForEachMacros:   
 59 |   - foreach
 60 |   - Q_FOREACH
 61 |   - BOOST_FOREACH
 62 | IncludeBlocks:   Preserve
 63 | IncludeCategories: 
 64 |   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
 65 |     Priority:        2
 66 |   - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
 67 |     Priority:        3
 68 |   - Regex:           '.*'
 69 |     Priority:        1
 70 | IncludeIsMainRegex: '(Test)?$'
 71 | IndentCaseLabels: false
 72 | IndentPPDirectives: None
 73 | IndentWidth:     2
 74 | IndentWrappedFunctionNames: false
 75 | JavaScriptQuotes: Leave
 76 | JavaScriptWrapImports: true
 77 | KeepEmptyLinesAtTheStartOfBlocks: true
 78 | MacroBlockBegin: ''
 79 | MacroBlockEnd:   ''
 80 | MaxEmptyLinesToKeep: 1
 81 | NamespaceIndentation: None
 82 | ObjCBlockIndentWidth: 2
 83 | ObjCSpaceAfterProperty: false
 84 | ObjCSpaceBeforeProtocolList: true
 85 | PenaltyBreakAssignment: 2
 86 | PenaltyBreakBeforeFirstCallParameter: 19
 87 | PenaltyBreakComment: 300
 88 | PenaltyBreakFirstLessLess: 120
 89 | PenaltyBreakString: 1000
 90 | PenaltyExcessCharacter: 1000000
 91 | PenaltyReturnTypeOnItsOwnLine: 60
 92 | PointerAlignment: Right
 93 | ReflowComments:  true
 94 | SortIncludes:    true
 95 | SortUsingDeclarations: true
 96 | SpaceAfterCStyleCast: false
 97 | SpaceAfterTemplateKeyword: true
 98 | SpaceBeforeAssignmentOperators: true
 99 | SpaceBeforeParens: ControlStatements
100 | SpaceInEmptyParentheses: false
101 | SpacesBeforeTrailingComments: 1
102 | SpacesInAngles:  false
103 | SpacesInContainerLiterals: true
104 | SpacesInCStyleCastParentheses: false
105 | SpacesInParentheses: false
106 | SpacesInSquareBrackets: false
107 | Standard:        Cpp11
108 | TabWidth:        8
109 | UseTab:          Never
110 | ...
111 | 
112 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on: pull_request
 4 | 
 5 | jobs:
 6 | 
 7 |   test:
 8 | 
 9 |     name: ${{ matrix.toolchain }}
10 |     runs-on: ${{ matrix.os }}
11 |     continue-on-error: true
12 | 
13 |     strategy:
14 | 
15 |       matrix:
16 | 
17 |         toolchain:
18 |           - macos-latest-clang
19 |           - macos-12-clang
20 |           - ubuntu-latest-clang
21 |           - ubuntu-latest-gcc
22 |           - windows-2019-msvc
23 |           - windows-latest-msvc
24 |           - windows-latest-clang
25 | 
26 |         include:
27 |           - toolchain: macos-latest-clang
28 |             os: macos-latest
29 |             c_compiler: clang
30 |             cxx_compiler: clang++
31 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
32 | 
33 |           - toolchain: macos-12-clang
34 |             os: macos-latest
35 |             c_compiler: clang
36 |             cxx_compiler: clang++
37 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
38 | 
39 |           - toolchain: ubuntu-latest-clang
40 |             os: ubuntu-latest
41 |             c_compiler: clang
42 |             cxx_compiler: clang++
43 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
44 | 
45 |           - toolchain: ubuntu-latest-gcc
46 |             os: ubuntu-latest
47 |             c_compiler: cc
48 |             cxx_compiler: g++
49 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
50 | 
51 |           - toolchain: windows-2019-msvc
52 |             os: windows-2019
53 |             c_compiler: msvc
54 |             cxx_compiler: msvc
55 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
56 | 
57 |           - toolchain: windows-latest-msvc
58 |             os: windows-latest
59 |             c_compiler: msvc
60 |             cxx_compiler: msvc
61 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release
62 | 
63 |           - toolchain: windows-latest-clang
64 |             os: windows-latest
65 |             c_compiler: clang-cl
66 |             cxx_compiler: clang-cl
67 |             cmake_opts: -DALPACA_BUILD_TESTS=on -DALPACA_BUILD_BENCHMARKS=on -DALPACA_BUILD_SAMPLES=on -DCMAKE_BUILD_TYPE=Release -T ClangCL
68 | 
69 |     steps:
70 | 
71 |     - name: Checkout Code
72 |       uses: actions/checkout@v2
73 | 
74 |     - name: Configure
75 |       working-directory: test
76 |       run: cmake -S . -B build ${{ matrix.cmake_opts }}
77 |       env:
78 |         CC: ${{ matrix.c_compiler }}
79 |         CXX: ${{ matrix.cxx_compiler }}
80 | 
81 |     - name: Build for ${{ matrix.os }} with ${{ matrix.compiler }}
82 |       working-directory: test
83 |       run: cmake --build build
84 | 
85 |     - name: Test
86 |       if: ${{ ! startsWith(matrix.os, 'windows') }}
87 |       working-directory: test/build
88 |       run: ./tests
89 | 
90 |     - name: Test (Windows)
91 |       if: ${{ startsWith(matrix.os, 'windows') }}
92 |       working-directory: test/build
93 |       run: ./Debug/tests.exe
94 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "python/pybind11"]
2 | 	path = python/pybind11
3 | 	url = https://github.com/pybind/pybind11
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2022 Pranav Srinivas Kumar <pranav.srinivas.kumar@gmail.com>
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/benchmark/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.14)
 2 | 
 3 | project(alpacaBenchmark CXX)
 4 | 
 5 | include(../cmake/project-is-top-level.cmake)
 6 | 
 7 | if(PROJECT_IS_TOP_LEVEL)
 8 |   find_package(alpaca REQUIRED)
 9 | endif()
10 | 
11 | find_package(benchmark CONFIG)
12 | if(NOT benchmark_FOUND)
13 |     message(STATUS "Using CMake Version ${CMAKE_VERSION}")
14 |     if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.11.0")
15 |         # User can fetch googlebenchmark
16 |         message(STATUS "Downloading GoogleBenchmark")
17 |         include(FetchContent)
18 |         set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE INTERNAL "")
19 |         # Do not build and run googlebenchmark tests
20 |         FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.5.2)
21 | 
22 |         FetchContent_MakeAvailable(googlebenchmark)
23 |     else()
24 |         message(FATAL_ERROR "GoogleBenchmark is missing. Use CMake >= 3.11 or download it")
25 |     endif()
26 | endif()
27 | 
28 | if (NOT CMAKE_BUILD_TYPE MATCHES Debug)
29 |   add_definitions(-DNDEBUG)
30 | endif()
31 | 
32 | if(NOT CMAKE_BUILD_TYPE)
33 |   set(CMAKE_BUILD_TYPE Release)
34 | endif()
35 | 
36 | # Set default compile flags for GCC
37 | if(CMAKE_COMPILER_IS_GNUCXX)
38 |   set(CMAKE_CXX_FLAGS "-Wall -Wextra")
39 |   set(CMAKE_CXX_FLAGS_DEBUG "-g")
40 |   set(CMAKE_CXX_FLAGS_RELEASE "-O3")
41 | endif(CMAKE_COMPILER_IS_GNUCXX)
42 | 
43 | function(add_benchmark NAME)
44 |   add_executable("${NAME}" "${NAME}.cpp")
45 |   target_link_libraries("${NAME}" PRIVATE alpaca::alpaca benchmark::benchmark)
46 |   target_compile_features("${NAME}" PRIVATE cxx_std_17)
47 |   add_custom_target("run_${NAME}" COMMAND "${NAME}" VERBATIM)
48 |   add_dependencies("run_${NAME}" "${NAME}")
49 | endfunction()
50 | 
51 | add_benchmark(benchmark_log_10k_serialize)
52 | add_benchmark(benchmark_log_10k_deserialize)
53 | add_benchmark(benchmark_mesh_125k_serialize)
54 | add_benchmark(benchmark_mesh_125k_deserialize)
55 | add_benchmark(benchmark_minecraft_players_50_serialize)
56 | add_benchmark(benchmark_minecraft_players_50_deserialize)


--------------------------------------------------------------------------------
/benchmark/benchmark_log_10k_deserialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "log.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_deserialize_log_10k(benchmark::State &state) {
11 |   {
12 |     auto logs = alpaca::benchmark::generate_logs(eng);
13 | 
14 |     std::array<uint8_t, 1000000> bytes;
15 | 
16 |     // serialize
17 |     auto data_size = alpaca::serialize(logs, bytes);
18 | 
19 |     std::error_code ec;
20 |     alpaca::benchmark::Logs logs_recovered;
21 | 
22 |     for (auto _ : state) {
23 |       // This code gets timed
24 |       logs_recovered = alpaca::deserialize<alpaca::benchmark::Logs>(bytes, ec);
25 |     }
26 | 
27 |     state.counters["Success"] = ((bool)ec == false);
28 |     state.counters["BytesOutput"] = data_size;
29 |     state.counters["Logs"] = logs_recovered.logs.size();
30 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
31 |   }
32 | }
33 | 
34 | BENCHMARK(BM_deserialize_log_10k);
35 | 
36 | BENCHMARK_MAIN();


--------------------------------------------------------------------------------
/benchmark/benchmark_log_10k_serialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "log.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_serialize_log_10k(benchmark::State &state) {
11 |   {
12 |     auto logs = alpaca::benchmark::generate_logs(eng);
13 | 
14 |     std::array<uint8_t, 1000000> bytes;
15 |     std::size_t data_size = 0;
16 | 
17 |     for (auto _ : state) {
18 |       // This code gets timed
19 |       data_size = alpaca::serialize(logs, bytes);
20 |     }
21 | 
22 |     std::error_code ec;
23 |     auto logs_recovered = alpaca::deserialize<alpaca::benchmark::Logs>(bytes, ec);
24 |     state.counters["Success"] = ((bool)ec == false);
25 |     state.counters["BytesOutput"] = data_size;
26 |     state.counters["Logs"] = logs_recovered.logs.size();
27 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
28 |   }
29 | }
30 | 
31 | BENCHMARK(BM_serialize_log_10k);
32 | 
33 | BENCHMARK_MAIN();


--------------------------------------------------------------------------------
/benchmark/benchmark_mesh_125k_deserialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "mesh.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_deserialize_mesh_125k(benchmark::State &state) {
11 |     constexpr auto NUM_TRIANGLES = 125000;
12 | 
13 |     alpaca::benchmark::Mesh m;
14 |     alpaca::benchmark::generate_mesh<NUM_TRIANGLES>(m, eng, real_distr);
15 | 
16 |     std::array<uint8_t, 6000024> bytes;
17 |     std::size_t data_size = alpaca::serialize(m, bytes);
18 | 
19 |     std::error_code ec;
20 |     alpaca::benchmark::Mesh m_recovered;
21 | 
22 |     for (auto _ : state) {
23 |         // This code gets timed
24 |         m_recovered = alpaca::deserialize<alpaca::benchmark::Mesh>(bytes, data_size, ec);
25 |     }
26 | 
27 |     state.counters["Success"] = ((bool)ec == false);
28 |     state.counters["BytesOutput"] = data_size;
29 |     std::size_t num_triangles_verified = 0;
30 | 
31 |     // Verify result
32 |     for (std::size_t i = 0; i < NUM_TRIANGLES; ++i) {
33 |         if (m_recovered.triangles[i].v0.x == m.triangles[i].v0.x && 
34 |         m_recovered.triangles[i].v0.y == m.triangles[i].v0.y &&
35 |         m_recovered.triangles[i].v0.z == m.triangles[i].v0.z && 
36 |         m_recovered.triangles[i].v1.x == m.triangles[i].v1.x && 
37 |         m_recovered.triangles[i].v1.y == m.triangles[i].v1.y &&
38 |         m_recovered.triangles[i].v1.z == m.triangles[i].v1.z &&
39 |         m_recovered.triangles[i].v2.x == m.triangles[i].v2.x && 
40 |         m_recovered.triangles[i].v2.y == m.triangles[i].v2.y &&
41 |         m_recovered.triangles[i].v2.z == m.triangles[i].v2.z &&
42 |         m_recovered.triangles[i].normal.x == m.triangles[i].normal.x && 
43 |         m_recovered.triangles[i].normal.y == m.triangles[i].normal.y &&
44 |         m_recovered.triangles[i].normal.z == m.triangles[i].normal.z) {
45 |             num_triangles_verified += 1;
46 |         }
47 |     }
48 | 
49 |     state.counters["Triangles"] = num_triangles_verified;
50 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
51 | }
52 | 
53 | BENCHMARK(BM_deserialize_mesh_125k);
54 | 
55 | BENCHMARK_MAIN();
56 | 


--------------------------------------------------------------------------------
/benchmark/benchmark_mesh_125k_serialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "mesh.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_serialize_mesh_125k(benchmark::State &state) {
11 |     constexpr auto NUM_TRIANGLES = 125000;
12 | 
13 |     alpaca::benchmark::Mesh m;
14 |     alpaca::benchmark::generate_mesh<NUM_TRIANGLES>(m, eng, real_distr);
15 | 
16 |     std::array<uint8_t, 6000024> bytes;
17 |     std::size_t data_size = 0;
18 | 
19 |     for (auto _ : state) {
20 |         // This code gets timed
21 |         data_size = alpaca::serialize(m, bytes);
22 |     }
23 | 
24 |     std::error_code ec;
25 |     auto m_recovered = alpaca::deserialize<alpaca::benchmark::Mesh>(bytes, ec);
26 |     state.counters["Success"] = ((bool)ec == false);
27 |     state.counters["BytesOutput"] = data_size;
28 |     std::size_t num_triangles_verified = 0;
29 | 
30 |     // Verify result
31 |     for (std::size_t i = 0; i < NUM_TRIANGLES; ++i) {
32 |         if (m_recovered.triangles[i].v0.x == m.triangles[i].v0.x && 
33 |         m_recovered.triangles[i].v0.y == m.triangles[i].v0.y &&
34 |         m_recovered.triangles[i].v0.z == m.triangles[i].v0.z && 
35 |         m_recovered.triangles[i].v1.x == m.triangles[i].v1.x && 
36 |         m_recovered.triangles[i].v1.y == m.triangles[i].v1.y &&
37 |         m_recovered.triangles[i].v1.z == m.triangles[i].v1.z &&
38 |         m_recovered.triangles[i].v2.x == m.triangles[i].v2.x && 
39 |         m_recovered.triangles[i].v2.y == m.triangles[i].v2.y &&
40 |         m_recovered.triangles[i].v2.z == m.triangles[i].v2.z &&
41 |         m_recovered.triangles[i].normal.x == m.triangles[i].normal.x && 
42 |         m_recovered.triangles[i].normal.y == m.triangles[i].normal.y &&
43 |         m_recovered.triangles[i].normal.z == m.triangles[i].normal.z) {
44 |             num_triangles_verified += 1;
45 |         }
46 |     }
47 | 
48 |     state.counters["Triangles"] = num_triangles_verified;
49 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
50 | }
51 | 
52 | BENCHMARK(BM_serialize_mesh_125k);
53 | 
54 | BENCHMARK_MAIN();
55 | 


--------------------------------------------------------------------------------
/benchmark/benchmark_minecraft_players_50_deserialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "log.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_deserialize_minecraft_players_50(benchmark::State &state) {
11 |   {
12 |     alpaca::benchmark::Players m;
13 | 
14 |     for (std::size_t i = 0; i < 50; ++i) {
15 |       m.players.push_back(alpaca::benchmark::generate_player(eng));
16 |     }
17 | 
18 |     constexpr auto OPTIONS = alpaca::options::fixed_length_encoding;
19 | 
20 |     std::array<uint8_t, 150000> bytes;
21 |     std::size_t data_size = alpaca::serialize<OPTIONS>(m, bytes);
22 | 
23 |     std::error_code ec;
24 |     alpaca::benchmark::Players m_recovered;
25 | 
26 |     for (auto _ : state) {
27 |       // This code gets timed
28 |       // serialize
29 |       m_recovered = alpaca::deserialize<OPTIONS, alpaca::benchmark::Players>(bytes, ec);
30 |     }
31 | 
32 |     state.counters["Success"] = ((bool)ec == false);
33 |     state.counters["BytesOutput"] = data_size;
34 |     state.counters["Players"] = m_recovered.players.size();
35 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
36 |   }
37 | }
38 | 
39 | BENCHMARK(BM_deserialize_minecraft_players_50);
40 | 
41 | BENCHMARK_MAIN();


--------------------------------------------------------------------------------
/benchmark/benchmark_minecraft_players_50_serialize.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <benchmark/benchmark.h>
 3 | #include "log.h"
 4 | #include <random>
 5 | 
 6 | std::random_device rd;
 7 | std::default_random_engine eng(rd());
 8 | std::uniform_real_distribution<float> real_distr(-1000.0f, 1000.0f);
 9 | 
10 | static void BM_serialize_minecraft_players_50(benchmark::State &state) {
11 |   {
12 |     alpaca::benchmark::Players m;
13 | 
14 |     for (std::size_t i = 0; i < 50; ++i) {
15 |       m.players.push_back(alpaca::benchmark::generate_player(eng));
16 |     }
17 | 
18 |     std::array<uint8_t, 150000> bytes;
19 |     std::size_t data_size = 0;
20 | 
21 |     constexpr auto OPTIONS = alpaca::options::fixed_length_encoding;
22 | 
23 |     for (auto _ : state) {
24 |       // This code gets timed
25 |       // serialize
26 |       data_size = alpaca::serialize<OPTIONS>(m, bytes);
27 |     }
28 | 
29 |     std::error_code ec;
30 |     auto m_recovered = alpaca::deserialize<OPTIONS, alpaca::benchmark::Players>(bytes, ec);
31 |     state.counters["Success"] = ((bool)ec == false);
32 |     state.counters["BytesOutput"] = data_size;
33 |     state.counters["Players"] = m_recovered.players.size();
34 |     state.counters["DataRate"] = benchmark::Counter(data_size, benchmark::Counter::kIsRate);
35 |   }
36 | }
37 | 
38 | BENCHMARK(BM_serialize_minecraft_players_50);
39 | 
40 | BENCHMARK_MAIN();


--------------------------------------------------------------------------------
/benchmark/log.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <vector>
 4 | #include "minecraft_save.h"
 5 | 
 6 | namespace alpaca {
 7 | 
 8 | namespace benchmark {
 9 | 
10 | struct Address {
11 |     uint32_t x0;
12 |     uint32_t x1;
13 |     uint32_t x2;
14 |     uint32_t x3;
15 | };
16 | 
17 | struct Log {
18 |     Address address;
19 |     std::string identity;
20 |     std::string userid;
21 |     std::string date;
22 |     std::string request;
23 |     uint32_t code;
24 |     uint64_t size;
25 | };
26 | 
27 | struct Logs {
28 |     std::vector<Log> logs;
29 | };
30 | 
31 | template <typename Engine>
32 | auto generate_address(Engine &eng) {
33 |     std::uniform_int_distribution<uint32_t> uint_distr(0, 20000);
34 |     return Address {
35 |         uint_distr(eng),
36 |         uint_distr(eng),
37 |         uint_distr(eng),
38 |         uint_distr(eng)
39 |     };
40 | }
41 | 
42 | template <typename Engine>
43 | auto generate_log(Engine &eng) {
44 |     std::uniform_int_distribution<uint32_t> uint32_distr(0, 20000);
45 |     std::uniform_int_distribution<uint64_t> uint64_distr(0, 20000);
46 | 
47 |     return Log {
48 |         generate_address(eng),
49 |         generate_string(12),
50 |         generate_string(8),
51 |         generate_string(16),
52 |         generate_string(32),
53 |         uint32_distr(eng),
54 |         uint64_distr(eng)
55 |     };
56 | }
57 | 
58 | template <typename Engine>
59 | auto generate_logs(Engine &eng) {
60 |     constexpr auto size = 10000;
61 |     Logs result{};
62 | 
63 |     for (std::size_t i = 0; i < size; ++i) {
64 |         result.logs.push_back(generate_log(eng));
65 |     }
66 | 
67 |     return result;
68 | }
69 | 
70 | }
71 | 
72 | }


--------------------------------------------------------------------------------
/benchmark/mesh.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <vector>
 3 | 
 4 | namespace alpaca {
 5 | 
 6 | namespace benchmark {
 7 | 
 8 | struct Vector3 {
 9 |   float x;
10 |   float y;
11 |   float z;
12 | };
13 | 
14 | struct Triangle {
15 |   Vector3 v0;
16 |   Vector3 v1;
17 |   Vector3 v2;
18 |   Vector3 normal;
19 | };
20 | 
21 | struct Mesh {
22 |   std::vector<Triangle> triangles;
23 | };
24 | 
25 | template <std::size_t NumTriangles, typename Engine, typename Distr>
26 | auto generate_mesh(Mesh& mesh, Engine& eng, Distr &distr) {
27 |     for (std::size_t i = 0; i < NumTriangles; ++i) {
28 |         mesh.triangles.push_back(Triangle{
29 |             Vector3{distr(eng), distr(eng), distr(eng)},
30 |             Vector3{distr(eng), distr(eng), distr(eng)},
31 |             Vector3{distr(eng), distr(eng), distr(eng)},
32 |             Vector3{distr(eng), distr(eng), distr(eng)}
33 |         });
34 |     }
35 | }
36 | 
37 | }
38 | 
39 | }


--------------------------------------------------------------------------------
/clang_format.bash:
--------------------------------------------------------------------------------
1 | clang-format -i include/alpaca/*.h include/alpaca/detail/*.h test/*.cpp include/alpaca/detail/types/*.h samples/*.cpp python/*.cpp python/*.h
2 | 


--------------------------------------------------------------------------------
/cmake/project-is-top-level.cmake:
--------------------------------------------------------------------------------
1 | # This variable is set by project() in CMake 3.21+
2 | string(
3 |     COMPARE EQUAL
4 |     "${CMAKE_SOURCE_DIR}" "${PROJECT_SOURCE_DIR}"
5 |     PROJECT_IS_TOP_LEVEL
6 | )


--------------------------------------------------------------------------------
/include/alpaca/detail/aggregate_arity.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <utility>
 3 | 
 4 | namespace alpaca {
 5 | 
 6 | namespace detail {
 7 | 
 8 | struct filler {
 9 |   template <typename type> operator type();
10 | };
11 | 
12 | template <typename aggregate, typename index_sequence = std::index_sequence<>,
13 |           typename = void>
14 | struct aggregate_arity : index_sequence {};
15 | 
16 | #ifdef __GNUC__
17 | #pragma GCC diagnostic push
18 | #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
19 | #endif
20 | 
21 | template <typename aggregate, std::size_t... indices>
22 | struct aggregate_arity<
23 |     aggregate, std::index_sequence<indices...>,
24 |     std::void_t<decltype(aggregate{(void(indices), std::declval<filler>())...,
25 |                                    std::declval<filler>()})>>
26 |     : aggregate_arity<aggregate,
27 |                       std::index_sequence<indices..., sizeof...(indices)>> {};
28 | 
29 | #ifdef __GNUC__
30 | #pragma GCC diagnostic pop
31 | #endif
32 | 
33 | } // namespace detail
34 | 
35 | } // namespace alpaca


--------------------------------------------------------------------------------
/include/alpaca/detail/field_type.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstdint>
 3 | 
 4 | namespace alpaca {
 5 | 
 6 | namespace detail {
 7 | 
 8 | enum class field_type : uint8_t {
 9 |   bool_,
10 |   char_,
11 |   uint8,
12 |   uint16,
13 |   uint32,
14 |   uint64,
15 |   int8,
16 |   int16,
17 |   int32,
18 |   int64,
19 |   float32,
20 |   float64,
21 |   enum_class,
22 |   string,
23 |   array,
24 |   vector,
25 |   map,
26 |   unordered_map,
27 |   set,
28 |   unordered_set,
29 |   optional,
30 |   pair,
31 |   tuple,
32 |   variant,
33 |   unique_ptr,
34 |   struct_,
35 |   chrono_duration,
36 |   list,
37 |   deque,
38 |   filesystem_path,
39 |   bitset,
40 | };
41 | 
42 | template <field_type value> constexpr uint8_t to_byte() {
43 |   return static_cast<uint8_t>(value);
44 | }
45 | 
46 | } // namespace detail
47 | 
48 | } // namespace alpaca
49 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/is_bitset.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_BITSET
 3 | #include <bitset>
 4 | #include <type_traits>
 5 | 
 6 | namespace alpaca {
 7 | 
 8 | namespace detail {
 9 | 
10 | // check if T is instantiation of Bitset
11 | template <typename T>
12 | struct is_bitset : std::false_type {};
13 | 
14 | template <std::size_t N>
15 | struct is_bitset<std::bitset<N>> : std::true_type {};
16 | 
17 | } // namespace detail
18 | 
19 | } // namespace alpaca
20 | 
21 | #endif // ALPACA_EXCLUDE_SUPPORT_STD_BITSET
22 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/is_specialization.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | 
 4 | namespace alpaca {
 5 | 
 6 | namespace detail {
 7 | 
 8 | // check if T is instantiation of U
 9 | template <typename Test, template <typename...> class Ref>
10 | struct is_specialization : std::false_type {};
11 | 
12 | template <template <typename...> class Ref, typename... Args>
13 | struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
14 | 
15 | } // namespace detail
16 | 
17 | } // namespace alpaca


--------------------------------------------------------------------------------
/include/alpaca/detail/options.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | 
 4 | namespace alpaca {
 5 | 
 6 | enum class options {
 7 |   none = 0,
 8 |   big_endian = 1,
 9 |   fixed_length_encoding = 2,
10 |   with_version = 4,
11 |   with_checksum = 8,
12 |   force_aligned_access = 16,
13 |   strict = 32,
14 | };
15 | 
16 | template <typename E> struct enable_bitmask_operators {
17 |   static constexpr bool enable = false;
18 | };
19 | 
20 | template <typename E>
21 | constexpr typename std::enable_if<enable_bitmask_operators<E>::enable, E>::type
22 | operator|(E lhs, E rhs) {
23 |   using underlying = typename std::underlying_type<E>::type;
24 |   return static_cast<E>(static_cast<underlying>(lhs) |
25 |                         static_cast<underlying>(rhs));
26 | }
27 | 
28 | namespace detail {
29 | 
30 | using size_t_serialized_type = uint32_t;
31 | 
32 | 
33 | template <typename T, T value, T flag> constexpr bool enum_has_flag() {
34 |   using underlying = typename std::underlying_type<T>::type;
35 |   return (static_cast<underlying>(value) & static_cast<underlying>(flag)) ==
36 |          static_cast<underlying>(flag);
37 | }
38 | 
39 | template <options O> constexpr bool big_endian() {
40 |   return enum_has_flag<options, O, options::big_endian>();
41 | }
42 | 
43 | template <options O> constexpr bool little_endian() { return !big_endian<O>(); }
44 | 
45 | template <options O> constexpr bool fixed_length_encoding() {
46 |   return enum_has_flag<options, O, options::fixed_length_encoding>();
47 | }
48 | 
49 | template <options O> constexpr bool with_version() {
50 |   return enum_has_flag<options, O, options::with_version>();
51 | }
52 | 
53 | template <options O> constexpr bool with_checksum() {
54 |   return enum_has_flag<options, O, options::with_checksum>();
55 | 
56 | }
57 | 
58 | template <options O> constexpr bool force_aligned_access() {
59 |   return enum_has_flag<options, O, options::force_aligned_access>();
60 | }
61 | 
62 | template <options O> constexpr bool strict() {
63 |   return enum_has_flag<options, O, options::strict>();
64 | }
65 | 
66 | } // namespace detail
67 | 
68 | template <> struct enable_bitmask_operators<options> {
69 |   static constexpr bool enable = true;
70 | };
71 | 
72 | } // namespace alpaca
73 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/output_container.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <array>
 3 | #include <fstream>
 4 | #include <system_error>
 5 | #include <vector>
 6 | 
 7 | namespace alpaca {
 8 | 
 9 | namespace detail {
10 | 
11 | static inline void append(const uint8_t &value, std::vector<uint8_t> &container,
12 |                           std::size_t &index) {
13 |   container.push_back(value);
14 |   index += 1;
15 | }
16 | 
17 | template <std::size_t N>
18 | void append(const uint8_t &value, std::array<uint8_t, N> &container,
19 |             std::size_t &index) {
20 |   container[index++] = value;
21 | }
22 | 
23 | static inline void append(const uint8_t &value, uint8_t container[],
24 |                           std::size_t &index) {
25 |   container[index++] = value;
26 | }
27 | 
28 | static inline void append(const uint8_t &value, std::ofstream &container,
29 |                           std::size_t &index) {
30 |   container << value;
31 |   index += 1;
32 | }
33 | 
34 | } // namespace detail
35 | 
36 | } // namespace alpaca
37 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/print_bytes.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <iomanip>
 3 | #include <iostream>
 4 | #include <vector>
 5 | 
 6 | namespace alpaca {
 7 | 
 8 | namespace detail {
 9 | 
10 | template <typename Container> static inline void print_bytes(Container &bytes) {
11 |   std::ios_base::fmtflags f(std::cout.flags());
12 | 
13 |   std::cout << "bytes[" << bytes.size() << "]:\n  ";
14 | 
15 |   for (std::size_t i = 0; i < bytes.size(); ++i) {
16 |     const auto &b = bytes[i];
17 |     std::cout << std::hex << "0x" << std::setfill('0') << std::setw(2) << (int)b
18 |               << " ";
19 |     if (i > 0 && (i + 1) % 8 == 0) {
20 |       std::cout << "\n  ";
21 |     }
22 |   }
23 |   std::cout << "\n";
24 | 
25 |   std::cout.flags(f);
26 | }
27 | 
28 | } // namespace detail
29 | 
30 | } // namespace alpaca


--------------------------------------------------------------------------------
/include/alpaca/detail/to_bytes.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <alpaca/detail/endian.h>
 3 | #include <alpaca/detail/variable_length_encoding.h>
 4 | #include <iterator>
 5 | 
 6 | namespace alpaca {
 7 | 
 8 | namespace detail {
 9 | 
10 | template <typename T, typename Container>
11 | void copy_bytes_in_range(const T &value, Container &bytes,
12 |                          std::size_t &byte_index) {
13 |   auto start = static_cast<const char *>(static_cast<const void *>(&value));
14 |   auto end = start + sizeof value;
15 |   for (auto i = start; i != end; ++i) {
16 |     append(static_cast<uint8_t>(*i), bytes, byte_index);
17 |   }
18 | }
19 | 
20 | template <options O, typename Container>
21 | void to_bytes_crc32(Container &bytes, std::size_t &byte_index,
22 |                     const uint32_t &original_value) {
23 |   uint32_t value = original_value;
24 |   update_value_based_on_alpaca_endian_rules<O, uint32_t>(value);
25 | 
26 |   copy_bytes_in_range(value, bytes, byte_index);
27 | }
28 | 
29 | // write as is
30 | template <options O, typename T, typename U>
31 | typename std::enable_if<
32 |     std::is_same_v<U, bool> || std::is_same_v<U, char> ||
33 |         std::is_same_v<U, wchar_t> || std::is_same_v<U, char16_t> ||
34 |         std::is_same_v<U, char32_t> || std::is_same_v<U, uint8_t> ||
35 |         std::is_same_v<U, uint16_t> || std::is_same_v<U, int8_t> ||
36 |         std::is_same_v<U, int16_t> || std::is_same_v<U, float> ||
37 |         std::is_same_v<U, double>,
38 |     void>::type
39 | to_bytes(T &bytes, std::size_t &byte_index, const U &original_value) {
40 | 
41 |   U value = original_value;
42 |   update_value_based_on_alpaca_endian_rules<O, U>(value);
43 | 
44 |   copy_bytes_in_range(value, bytes, byte_index);
45 | }
46 | 
47 | // encode as variable-length
48 | template <options O, typename T, typename U>
49 | typename std::enable_if<
50 |      std::is_same_v<U, uint32_t> || std::is_same_v<U, uint64_t> ||
51 |      std::is_same_v<U, int32_t> || std::is_same_v<U, int64_t> ||
52 |      std::is_same_v<U, unsigned long> || std::is_same_v<U, long> ||
53 |      std::is_same_v<U, unsigned long long> || std::is_same_v<U, long long>,
54 |     void>::type
55 | to_bytes(T &bytes, std::size_t &byte_index, const U &original_value) {
56 | 
57 |   static_assert(!std::is_same_v<T, size_t>, "Unable to directly serialize size_t type");
58 | 
59 |   U value = original_value;
60 |   update_value_based_on_alpaca_endian_rules<O, U>(value);
61 | 
62 |   constexpr auto use_fixed_length_encoding = (
63 |       // Do not perform VLQ if:
64 |       // 1. if the system is little-endian and the requested byte order is
65 |       // big-endian
66 |       // 2. if the system is big-endian and the requested byte order is
67 |       // little-endian
68 |       // 3. If fixed length encoding is requested
69 |       (is_system_little_endian() && detail::big_endian<O>()) ||
70 |       (detail::fixed_length_encoding<O>()));
71 | 
72 |   if constexpr (use_fixed_length_encoding) {
73 |     copy_bytes_in_range(value, bytes, byte_index);
74 |   } else {
75 |     encode_varint<U, T>(value, bytes, byte_index);
76 |   }
77 | }
78 | 
79 | // enum class
80 | template <options O, typename T, typename U>
81 | typename std::enable_if<std::is_enum<U>::value, void>::type
82 | to_bytes(T &bytes, std::size_t &byte_index, const U &value) {
83 |   using underlying_type =
84 |       typename std::decay<typename std::underlying_type<U>::type>::type;
85 |   to_bytes<O, T, underlying_type>(bytes, byte_index,
86 |                                   static_cast<underlying_type>(value));
87 | }
88 | 
89 | } // namespace detail
90 | 
91 | } // namespace alpaca
92 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/array.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_ARRAY
 3 | #include <alpaca/detail/type_info.h>
 4 | #include <array>
 5 | #include <system_error>
 6 | #include <vector>
 7 | 
 8 | namespace alpaca {
 9 | 
10 | namespace detail {
11 | 
12 | template <typename T>
13 | typename std::enable_if<is_array_type<T>::value, void>::type type_info(
14 |     std::vector<uint8_t> &typeids,
15 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
16 |   typeids.push_back(to_byte<field_type::array>());
17 |   typeids.push_back((size_t_serialized_type) std::tuple_size_v<T>);
18 |   using value_type = typename T::value_type;
19 |   type_info<value_type>(typeids, struct_visitor_map);
20 | }
21 | 
22 | template <options O, typename T, typename Container>
23 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
24 | 
25 | template <options O, typename Container, typename T, std::size_t N>
26 | void to_bytes(Container &bytes, std::size_t &byte_index,
27 |               const std::array<T, N> &input) {
28 |   // value of each element in list
29 |   for (const auto &v : input) {
30 |     to_bytes_router<O>(v, bytes, byte_index);
31 |   }
32 | }
33 | 
34 | template <options O, typename T, typename Container>
35 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
36 |                        std::size_t &end_index, std::error_code &error_code);
37 | 
38 | template <options O, typename T, typename Container>
39 | void from_bytes_to_array(T &value, Container &bytes, std::size_t &current_index,
40 |                          std::size_t &end_index, std::error_code &error_code) {
41 | 
42 |   using decayed_value_type = typename std::decay<typename T::value_type>::type;
43 | 
44 |   constexpr auto size = (size_t_serialized_type) std::tuple_size<T>::value;
45 | 
46 |   if (size > end_index - current_index) {
47 |     // size is greater than the number of bytes remaining
48 |     error_code = std::make_error_code(std::errc::value_too_large);
49 | 
50 |     // stop here
51 |     return;
52 |   }
53 | 
54 |   // read `size` bytes and save to value
55 |   for (size_t_serialized_type i = 0; i < size; ++i) {
56 |     decayed_value_type v{};
57 |     from_bytes_router<O>(v, bytes, current_index, end_index, error_code);
58 |     value[i] = v;
59 |   }
60 | }
61 | 
62 | template <options O, typename U, typename Container, std::size_t N>
63 | bool from_bytes(std::array<U, N> &output, Container &bytes,
64 |                 std::size_t &byte_index, std::size_t &end_index,
65 |                 std::error_code &error_code) {
66 | 
67 |   if (byte_index >= end_index) {
68 |     // end of input
69 |     // return true for forward compatibility, unless strict mode is enabled
70 |     if constexpr (detail::strict<O>()) {
71 |       error_code = std::make_error_code(std::errc::bad_message);
72 |       return false;
73 |     } else {
74 |       return true;
75 |     }
76 |   }
77 | 
78 |   from_bytes_to_array<O>(output, bytes, byte_index, end_index, error_code);
79 |   return true;
80 | }
81 | 
82 | } // namespace detail
83 | 
84 | } // namespace alpaca
85 | #endif
86 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/deque.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_DEQUE
  3 | #include <alpaca/detail/to_bytes.h>
  4 | #include <alpaca/detail/type_info.h>
  5 | #include <deque>
  6 | #include <system_error>
  7 | 
  8 | namespace alpaca {
  9 | 
 10 | namespace detail {
 11 | 
 12 | template <typename T>
 13 | typename std::enable_if<is_specialization<T, std::deque>::value, void>::type
 14 | type_info(
 15 |     std::vector<uint8_t> &typeids,
 16 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
 17 |   typeids.push_back(to_byte<field_type::deque>());
 18 |   using value_type = typename T::value_type;
 19 |   type_info<value_type>(typeids, struct_visitor_map);
 20 | }
 21 | 
 22 | template <options O, typename T, typename Container>
 23 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
 24 | 
 25 | template <options O, typename T, typename Container>
 26 | void to_bytes_from_deque_type(const T &input, Container &bytes,
 27 |                               std::size_t &byte_index) {
 28 |   // save deque size
 29 |   to_bytes_router<O, size_t_serialized_type>(input.size(), bytes, byte_index);
 30 | 
 31 |   // value of each element in deque
 32 |   for (const auto &v : input) {
 33 |     // check if the value_type is a nested deque type
 34 |     to_bytes_router<O>(v, bytes, byte_index);
 35 |   }
 36 | }
 37 | 
 38 | template <options O, typename Container, typename U>
 39 | void to_bytes(Container &bytes, std::size_t &byte_index,
 40 |               const std::deque<U> &input) {
 41 |   to_bytes_from_deque_type<O>(input, bytes, byte_index);
 42 | }
 43 | 
 44 | template <options O, typename T, typename Container>
 45 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
 46 |                        std::size_t &end_index, std::error_code &error_code);
 47 | 
 48 | template <options O, typename T, typename Container>
 49 | bool from_bytes_to_deque(std::deque<T> &value, Container &bytes,
 50 |                          std::size_t &current_index, std::size_t &end_index,
 51 |                          std::error_code &error_code) {
 52 | 
 53 |   if (current_index >= end_index) {
 54 |     // end of input
 55 |     // return true for forward compatibility, unless strict mode is enabled
 56 |     if constexpr (detail::strict<O>()) {
 57 |       error_code = std::make_error_code(std::errc::bad_message);
 58 |       return false;
 59 |     } else {
 60 |       return true;
 61 |     }
 62 |   }
 63 | 
 64 |   // current byte is the size of the vector
 65 |   size_t_serialized_type size = 0;
 66 |   detail::from_bytes<O, size_t_serialized_type>(size, bytes, current_index, end_index,
 67 |                                      error_code);
 68 | 
 69 |   if (size > end_index - current_index) {
 70 |     // size is greater than the number of bytes remaining
 71 |     error_code = std::make_error_code(std::errc::value_too_large);
 72 | 
 73 |     // stop here
 74 |     return false;
 75 |   }
 76 | 
 77 |   // read `size` bytes and save to value
 78 |   for (size_t_serialized_type i = 0; i < size; ++i) {
 79 |     T v{};
 80 |     from_bytes_router<O>(v, bytes, current_index, end_index, error_code);
 81 |     if (error_code) {
 82 |       // something went wrong
 83 |       return false;
 84 |     }
 85 |     value.push_back(v);
 86 |   }
 87 | 
 88 |   return true;
 89 | }
 90 | 
 91 | template <options O, typename T, typename Container>
 92 | bool from_bytes(std::deque<T> &output, Container &bytes,
 93 |                 std::size_t &byte_index, std::size_t &end_index,
 94 |                 std::error_code &error_code) {
 95 |   return from_bytes_to_deque<O>(output, bytes, byte_index, end_index,
 96 |                                 error_code);
 97 | }
 98 | 
 99 | } // namespace detail
100 | 
101 | } // namespace alpaca
102 | #endif
103 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/duration.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_CHRONO
 3 | #include <alpaca/detail/options.h>
 4 | #include <alpaca/detail/type_info.h>
 5 | #include <chrono>
 6 | #include <system_error>
 7 | #include <vector>
 8 | 
 9 | namespace alpaca {
10 | 
11 | namespace detail {
12 | 
13 | template <typename T>
14 | typename std::enable_if<is_specialization<T, std::chrono::duration>::value,
15 |                         void>::type
16 | type_info(
17 |     std::vector<uint8_t> &typeids,
18 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
19 |   typeids.push_back(to_byte<field_type::chrono_duration>());
20 | 
21 |   // save the rep type of duration
22 |   using rep = typename T::rep;
23 |   type_info<rep>(typeids, struct_visitor_map);
24 | }
25 | 
26 | template <options O, typename T, typename Container>
27 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
28 | 
29 | template <options O, typename Container, typename Rep, typename Period>
30 | void to_bytes(Container &bytes, std::size_t &byte_index,
31 |               const std::chrono::duration<Rep, Period> &input) {
32 |   // save the count
33 |   to_bytes_router<O>(input.count(), bytes, byte_index);
34 | }
35 | 
36 | template <options O, typename T, typename Container>
37 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
38 |                        std::size_t &end_index, std::error_code &error_code);
39 | 
40 | template <options O, typename Rep, typename Period, typename Container>
41 | bool from_bytes(std::chrono::duration<Rep, Period> &output, Container &bytes,
42 |                 std::size_t &byte_index, std::size_t &end_index,
43 |                 std::error_code &error_code) {
44 | 
45 |   if (byte_index >= end_index) {
46 |     // end of input
47 |     // return true for forward compatibility, unless strict mode is enabled
48 |     if constexpr (detail::strict<O>()) {
49 |       error_code = std::make_error_code(std::errc::bad_message);
50 |       return false;
51 |     } else {
52 |       return true;
53 |     }
54 |   }
55 | 
56 |   Rep count{0};
57 |   from_bytes_router<O>(count, bytes, byte_index, end_index, error_code);
58 | 
59 |   // Use explicit constructor
60 |   //   constexpr explicit duration( const Rep2& r );
61 |   // to construct the duration type
62 |   output = std::chrono::duration<Rep, Period>{count};
63 | 
64 |   return true;
65 | }
66 | 
67 | } // namespace detail
68 | 
69 | } // namespace alpaca
70 | #endif
71 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/filesystem_path.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_FILESYSTEM_PATH
 3 | #include <alpaca/detail/from_bytes.h>
 4 | #include <alpaca/detail/to_bytes.h>
 5 | #include <alpaca/detail/type_info.h>
 6 | #include <filesystem>
 7 | #include <system_error>
 8 | #include <vector>
 9 | 
10 | namespace alpaca {
11 | 
12 | namespace detail {
13 | 
14 | template <typename T>
15 | typename std::enable_if<std::is_same<T, std::filesystem::path>::value,
16 |                         void>::type
17 | type_info(std::vector<uint8_t> &typeids,
18 |           std::unordered_map<std::string_view, std::size_t> &) {
19 |   typeids.push_back(to_byte<field_type::filesystem_path>());
20 | }
21 | 
22 | template <options O, typename T, typename Container>
23 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
24 | 
25 | template <options O, typename Container>
26 | void to_bytes(Container &bytes, std::size_t &byte_index,
27 |               const std::filesystem::path &input) {
28 |   // save string length
29 |   to_bytes_router<O>((size_t_serialized_type)input.native().size(), bytes,
30 |                      byte_index);
31 | 
32 |   for (const auto &c : input.native()) {
33 |     to_bytes<O>(bytes, byte_index, c);
34 |   }
35 | }
36 | 
37 | template <options O, typename Container>
38 | bool from_bytes(std::filesystem::path &value, Container &bytes,
39 |                 std::size_t &current_index, std::size_t &end_index,
40 |                 std::error_code &error_code) {
41 | 
42 |   if (current_index >= end_index) {
43 |     // end of input
44 |     // return true for forward compatibility, unless strict mode is enabled
45 |     if constexpr (detail::strict<O>()) {
46 |       error_code = std::make_error_code(std::errc::bad_message);
47 |       return false;
48 |     } else {
49 |       return true;
50 |     }
51 |   }
52 | 
53 |   // current byte is the length of the string
54 |   size_t_serialized_type size = 0;
55 |   detail::from_bytes<O, size_t_serialized_type>(size, bytes, current_index,
56 |                                                 end_index, error_code);
57 | 
58 |   if (size > end_index - current_index) {
59 |     // size is greater than the number of bytes remaining
60 |     error_code = std::make_error_code(std::errc::value_too_large);
61 | 
62 |     // stop here
63 |     return false;
64 |   }
65 | 
66 |   // read `size` bytes and save to value
67 |   std::filesystem::path::string_type buff;
68 |   using CharType = std::filesystem::path::value_type;
69 | 
70 |   buff.reserve(size * sizeof(CharType));
71 | 
72 |   for (std::size_t i = 0; i < size; ++i) {
73 |     CharType character{};
74 |     from_bytes<O>(character, bytes, current_index, end_index, error_code);
75 |     buff += character;
76 |   }
77 | 
78 |   value = std::move(buff);
79 |   return true;
80 | }
81 | 
82 | } // namespace detail
83 | 
84 | } // namespace alpaca
85 | #endif
86 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/glm_vector.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifdef ALPACA_INCLUDE_SUPPORT_GLM_VECTOR
 3 | #include <alpaca/detail/types/array.h>
 4 | 
 5 | #include <glm/ext/vector_float3.hpp>
 6 | #include <system_error>
 7 | #include <unordered_map>
 8 | #include <vector>
 9 | 
10 | namespace alpaca {
11 | 
12 | namespace detail {
13 | 
14 | 
15 | template <typename T> struct is_glm_vec : std::false_type {};
16 | 
17 | template <int L, typename T, glm::qualifier Q>
18 | struct is_glm_vec<glm::vec<L, T, Q>> : std::true_type {};
19 | 
20 | template <typename T>
21 | typename std::enable_if<is_glm_vec<T>::value, void>::type
22 | type_info(
23 |     std::vector<uint8_t> &typeids,
24 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
25 | 	type_info<std::array<typename T::T, T::L>>(typeids, struct_visitor_map);
26 | }
27 | 
28 | template <options O, typename Container, int L, typename T, glm::qualifier Q>
29 | void to_bytes(Container &bytes, std::size_t &byte_index, const glm::vec<L, T, Q> &input) {
30 |     std::array<T, L> data;
31 | 	for (int i = 0; i < L; i++)
32 | 		data[i] = input[i];
33 | 
34 |     to_bytes<O, Container, T, L>(bytes, byte_index, data);
35 | }
36 | 
37 | template <options O, int L, typename T, glm::qualifier Q, typename Container>
38 | bool from_bytes(glm::vec<L, T, Q> &output, Container &bytes, std::size_t &byte_index, std::size_t &end_index,
39 |                 std::error_code &error_code) {
40 |     std::array<T, L> output_array;
41 |     from_bytes<O, T, Container, L>(output_array, bytes, byte_index, end_index, error_code);
42 | 
43 | 	for (int i = 0; i < L; i++)
44 | 		output[i] = output_array[i];
45 | 
46 |     return true;
47 | }
48 | 
49 | }  // namespace detail
50 | 
51 | }  // namespace alpaca
52 | #endif
53 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/list.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_LIST
  3 | #include <alpaca/detail/to_bytes.h>
  4 | #include <alpaca/detail/type_info.h>
  5 | #include <list>
  6 | #include <system_error>
  7 | 
  8 | namespace alpaca {
  9 | 
 10 | namespace detail {
 11 | 
 12 | template <typename T>
 13 | typename std::enable_if<is_specialization<T, std::list>::value, void>::type
 14 | type_info(
 15 |     std::vector<uint8_t> &typeids,
 16 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
 17 |   typeids.push_back(to_byte<field_type::list>());
 18 |   using value_type = typename T::value_type;
 19 |   type_info<value_type>(typeids, struct_visitor_map);
 20 | }
 21 | 
 22 | template <options O, typename T, typename Container>
 23 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
 24 | 
 25 | template <options O, typename T, typename Container>
 26 | void to_bytes_from_list_type(const T &input, Container &bytes,
 27 |                              std::size_t &byte_index) {
 28 |   // save list size
 29 |   to_bytes_router<O, size_t_serialized_type>(input.size(), bytes, byte_index);
 30 | 
 31 |   // value of each element in list
 32 |   for (const auto &v : input) {
 33 |     // check if the value_type is a nested list type
 34 |     to_bytes_router<O>(v, bytes, byte_index);
 35 |   }
 36 | }
 37 | 
 38 | template <options O, typename Container, typename U>
 39 | void to_bytes(Container &bytes, std::size_t &byte_index,
 40 |               const std::list<U> &input) {
 41 |   to_bytes_from_list_type<O>(input, bytes, byte_index);
 42 | }
 43 | 
 44 | template <options O, typename T, typename Container>
 45 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
 46 |                        std::size_t &end_index, std::error_code &error_code);
 47 | 
 48 | template <options O, typename T, typename Container>
 49 | bool from_bytes_to_list(std::list<T> &value, Container &bytes,
 50 |                         std::size_t &current_index, std::size_t &end_index,
 51 |                         std::error_code &error_code) {
 52 | 
 53 |   if (current_index >= end_index) {
 54 |     // end of input
 55 |     // return true for forward compatibility, unless strict mode is enabled
 56 |     if constexpr (detail::strict<O>()) {
 57 |       error_code = std::make_error_code(std::errc::bad_message);
 58 |       return false;
 59 |     } else {
 60 |       return true;
 61 |     }
 62 |   }
 63 | 
 64 |   // current byte is the size of the vector
 65 |   size_t_serialized_type size = 0;
 66 |   detail::from_bytes<O, size_t_serialized_type>(size, bytes, current_index, end_index,
 67 |                                      error_code);
 68 | 
 69 |   if (size > end_index - current_index) {
 70 |     // size is greater than the number of bytes remaining
 71 |     error_code = std::make_error_code(std::errc::value_too_large);
 72 | 
 73 |     // stop here
 74 |     return false;
 75 |   }
 76 | 
 77 |   // read `size` bytes and save to value
 78 |   for (std::size_t i = 0; i < size; ++i) {
 79 |     T v{};
 80 |     from_bytes_router<O>(v, bytes, current_index, end_index, error_code);
 81 |     if (error_code) {
 82 |       // something went wrong
 83 |       return false;
 84 |     }
 85 |     value.push_back(v);
 86 |   }
 87 | 
 88 |   return true;
 89 | }
 90 | 
 91 | template <options O, typename T, typename Container>
 92 | bool from_bytes(std::list<T> &output, Container &bytes, std::size_t &byte_index,
 93 |                 std::size_t &end_index, std::error_code &error_code) {
 94 |   return from_bytes_to_list<O>(output, bytes, byte_index, end_index,
 95 |                                error_code);
 96 | }
 97 | 
 98 | } // namespace detail
 99 | 
100 | } // namespace alpaca
101 | #endif
102 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/optional.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_OPTIONAL
 3 | #include <alpaca/detail/type_info.h>
 4 | #include <optional>
 5 | #include <system_error>
 6 | #include <vector>
 7 | 
 8 | namespace alpaca {
 9 | 
10 | namespace detail {
11 | 
12 | template <typename T>
13 | typename std::enable_if<is_specialization<T, std::optional>::value, void>::type
14 | type_info(
15 |     std::vector<uint8_t> &typeids,
16 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
17 |   typeids.push_back(to_byte<field_type::optional>());
18 |   using value_type = typename T::value_type;
19 |   type_info<value_type>(typeids, struct_visitor_map);
20 | }
21 | 
22 | template <options O, typename T, typename Container>
23 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
24 | 
25 | template <options O, typename Container, typename U>
26 | void to_bytes(Container &bytes, std::size_t &byte_index,
27 |               const std::optional<U> &input) {
28 |   const auto has_value = input.has_value();
29 | 
30 |   // save if optional has value
31 |   to_bytes_router<O, bool>(has_value, bytes, byte_index);
32 | 
33 |   // save value
34 |   if (has_value) {
35 |     to_bytes_router<O, U>(input.value(), bytes, byte_index);
36 |   }
37 | }
38 | 
39 | template <options O, typename T, typename Container>
40 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
41 |                        std::size_t &end_index, std::error_code &error_code);
42 | 
43 | template <options O, typename T, typename Container>
44 | bool from_bytes(std::optional<T> &output, Container &bytes,
45 |                 std::size_t &byte_index, std::size_t &end_index,
46 |                 std::error_code &error_code) {
47 | 
48 |   if (byte_index >= end_index) {
49 |     // end of input
50 |     // return true for forward compatibility, unless strict mode is enabled
51 |     if constexpr (detail::strict<O>()) {
52 |       error_code = std::make_error_code(std::errc::bad_message);
53 |       return false;
54 |     } else {
55 |       return true;
56 |     }
57 |   }
58 | 
59 |   auto current_byte = bytes[byte_index];
60 | 
61 |   // check if has_value has a legal value of either 0 or 1
62 |   if (current_byte != 0x00 && current_byte != 0x01) {
63 |     // expected either 0 or 1, got something else
64 |     error_code = std::make_error_code(std::errc::illegal_byte_sequence);
65 | 
66 |     // stop here
67 |     return false;
68 |   }
69 | 
70 |   // current byte is the `has_value` byte
71 |   bool has_value = static_cast<bool>(bytes[byte_index++]);
72 | 
73 |   if (has_value) {
74 |     // read value of optional
75 |     T value;
76 |     from_bytes_router<O>(value, bytes, byte_index, end_index, error_code);
77 |     output = value;
78 |   }
79 | 
80 |   return true;
81 | }
82 | 
83 | } // namespace detail
84 | 
85 | } // namespace alpaca
86 | #endif
87 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/pair.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_PAIR
 3 | #include <alpaca/detail/type_info.h>
 4 | #include <system_error>
 5 | #include <utility>
 6 | #include <vector>
 7 | 
 8 | namespace alpaca {
 9 | 
10 | namespace detail {
11 | 
12 | template <typename T>
13 | typename std::enable_if<is_specialization<T, std::pair>::value, void>::type
14 | type_info(
15 |     std::vector<uint8_t> &typeids,
16 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
17 |   typeids.push_back(to_byte<field_type::pair>());
18 | 
19 |   using first_type = typename T::first_type;
20 |   type_info<first_type>(typeids, struct_visitor_map);
21 | 
22 |   using second_type = typename T::second_type;
23 |   type_info<second_type>(typeids, struct_visitor_map);
24 | }
25 | 
26 | template <options O, typename T, typename Container>
27 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
28 | 
29 | template <options O, typename Container, typename U, typename V>
30 | void to_bytes(Container &bytes, std::size_t &byte_index,
31 |               const std::pair<U, V> &input) {
32 |   to_bytes_router<O>(input.first, bytes, byte_index);
33 |   to_bytes_router<O>(input.second, bytes, byte_index);
34 | }
35 | 
36 | template <options O, typename T, typename Container>
37 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
38 |                        std::size_t &end_index, std::error_code &error_code);
39 | 
40 | template <options O, typename T, typename U, typename Container>
41 | bool from_bytes(std::pair<T, U> &output, Container &bytes,
42 |                 std::size_t &byte_index, std::size_t &end_index,
43 |                 std::error_code &error_code) {
44 | 
45 |   if (byte_index >= end_index) {
46 |     // end of input
47 |     // return true for forward compatibility, unless strict mode is enabled
48 |     if constexpr (detail::strict<O>()) {
49 |       error_code = std::make_error_code(std::errc::bad_message);
50 |       return false;
51 |     } else {
52 |       return true;
53 |     }
54 |   }
55 | 
56 |   from_bytes_router<O>(output.first, bytes, byte_index, end_index, error_code);
57 |   from_bytes_router<O>(output.second, bytes, byte_index, end_index, error_code);
58 | 
59 |   return true;
60 | }
61 | 
62 | } // namespace detail
63 | 
64 | } // namespace alpaca
65 | #endif
66 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/unique_ptr.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_UNIQUE_PTR
 3 | #include <alpaca/detail/to_bytes.h>
 4 | #include <alpaca/detail/type_info.h>
 5 | #include <memory>
 6 | #include <system_error>
 7 | #include <vector>
 8 | 
 9 | namespace alpaca {
10 | 
11 | namespace detail {
12 | 
13 | template <typename T>
14 | typename std::enable_if<is_specialization<T, std::unique_ptr>::value,
15 |                         void>::type
16 | type_info(
17 |     std::vector<uint8_t> &typeids,
18 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
19 |   typeids.push_back(to_byte<field_type::unique_ptr>());
20 |   using element_type = typename T::element_type;
21 |   type_info<element_type>(typeids, struct_visitor_map);
22 | }
23 | 
24 | template <options O, typename T, typename Container>
25 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
26 | 
27 | template <options O, typename Container, typename U>
28 | void to_bytes(Container &bytes, std::size_t &byte_index,
29 |               const std::unique_ptr<U> &input) {
30 |   auto has_value = false;
31 |   if (input) {
32 |     has_value = true;
33 |   }
34 | 
35 |   // save if ptr has value
36 |   to_bytes_router<O, bool>(has_value, bytes, byte_index);
37 | 
38 |   // save value
39 |   if (has_value) {
40 |     to_bytes_router<O, U>(*input, bytes, byte_index);
41 |   }
42 | }
43 | 
44 | template <options O, typename T, typename Container>
45 | void from_bytes_router(T &output, Container &bytes, std::size_t &byte_index,
46 |                        std::size_t &end_index, std::error_code &error_code);
47 | 
48 | template <options O, typename T, typename Container>
49 | bool from_bytes(std::unique_ptr<T> &output, Container &bytes,
50 |                 std::size_t &byte_index, std::size_t &end_index,
51 |                 std::error_code &error_code) {
52 | 
53 |   if (byte_index >= end_index) {
54 |     // end of input
55 |     // return true for forward compatibility, unless strict mode is enabled
56 |     if constexpr (detail::strict<O>()) {
57 |       error_code = std::make_error_code(std::errc::bad_message);
58 |       return false;
59 |     } else {
60 |       return true;
61 |     }
62 |   }
63 | 
64 |   auto current_byte = bytes[byte_index];
65 | 
66 |   // check if has_value has a legal value of either 0 or 1
67 |   if (current_byte != 0x00 && current_byte != 0x01) {
68 |     // expected either 0 or 1, got something else
69 |     error_code = std::make_error_code(std::errc::illegal_byte_sequence);
70 | 
71 |     // stop here
72 |     return false;
73 |   }
74 | 
75 |   // current byte is the `has_value` byte
76 |   bool has_value = static_cast<bool>(bytes[byte_index++]);
77 | 
78 |   if (has_value) {
79 |     // read value of unique_ptr
80 |     T value{};
81 |     from_bytes_router<O>(value, bytes, byte_index, end_index, error_code);
82 |     output = std::unique_ptr<T>(new T{std::move(value)});
83 |   } else {
84 |     output = nullptr;
85 |   }
86 | 
87 |   return true;
88 | }
89 | 
90 | } // namespace detail
91 | 
92 | } // namespace alpaca
93 | #endif
94 | 


--------------------------------------------------------------------------------
/include/alpaca/detail/types/variant.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef ALPACA_EXCLUDE_SUPPORT_STD_VARIANT
 3 | #include <alpaca/detail/type_info.h>
 4 | #include <alpaca/detail/variable_length_encoding.h>
 5 | #include <alpaca/detail/variant_nth_field.h>
 6 | #include <system_error>
 7 | #include <variant>
 8 | #include <vector>
 9 | 
10 | namespace alpaca {
11 | 
12 | namespace detail {
13 | 
14 | template <typename T, std::size_t N, std::size_t I>
15 | void type_info_variant_helper(
16 |     std::vector<uint8_t> &typeids,
17 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
18 |   if constexpr (I < N) {
19 | 
20 |     // save current type
21 |     type_info<std::variant_alternative_t<I, T>>(typeids, struct_visitor_map);
22 | 
23 |     // go to next type
24 |     type_info_variant_helper<T, N, I + 1>(typeids, struct_visitor_map);
25 |   }
26 | }
27 | 
28 | template <typename T>
29 | typename std::enable_if<is_specialization<T, std::variant>::value, void>::type
30 | type_info(
31 |     std::vector<uint8_t> &typeids,
32 |     std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
33 |   typeids.push_back(to_byte<field_type::variant>());
34 |   constexpr auto variant_size = std::variant_size_v<T>;
35 |   type_info_variant_helper<T, variant_size, 0>(typeids, struct_visitor_map);
36 | }
37 | 
38 | template <options O, typename T, typename Container>
39 | void to_bytes_router(const T &input, Container &bytes, std::size_t &byte_index);
40 | 
41 | template <options O, typename Container, typename... U>
42 | void to_bytes(Container &bytes, std::size_t &byte_index,
43 |               const std::variant<U...> &input) {
44 |   std::size_t index = input.index();
45 | 
46 |   // save index of variant
47 |   to_bytes_router<O, std::size_t>(index, bytes, byte_index);
48 | 
49 |   // save value of variant
50 |   const auto visitor = [&bytes, &byte_index](auto &&arg) {
51 |     to_bytes_router<O>(arg, bytes, byte_index);
52 |   };
53 |   std::visit(visitor, input);
54 | }
55 | 
56 | template <options O, typename Container, typename... T>
57 | bool from_bytes(std::variant<T...> &output, Container &bytes,
58 |                 std::size_t &byte_index, std::size_t &end_index,
59 |                 std::error_code &error_code) {
60 | 
61 |   if (byte_index >= end_index) {
62 |     // end of input
63 |     // return true for forward compatibility, unless strict mode is enabled
64 |     if constexpr (detail::strict<O>()) {
65 |       error_code = std::make_error_code(std::errc::bad_message);
66 |       return false;
67 |     } else {
68 |       return true;
69 |     }
70 |   }
71 | 
72 |   // current byte is the index of the variant value
73 |   std::size_t index = 0;
74 |   detail::from_bytes<O, std::size_t>(index, bytes, byte_index, end_index,
75 |                                      error_code);
76 | 
77 |   // read bytes as value_type = variant@index
78 |   detail::set_variant_value<O, std::variant<T...>, Container>(
79 |       output, index, bytes, byte_index, end_index, error_code);
80 | 
81 |   return true;
82 | }
83 | 
84 | } // namespace detail
85 | 
86 | } // namespace alpaca
87 | #endif
88 | 


--------------------------------------------------------------------------------
/packaging/pkgconfig.pc.in:
--------------------------------------------------------------------------------
1 | prefix=@CMAKE_INSTALL_PREFIX@
2 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
3 | 
4 | Name: @PROJECT_NAME@
5 | Description: @PROJECT_DESCRIPTION@
6 | Version: @PROJECT_VERSION@
7 | Cflags: -I${includedir}


--------------------------------------------------------------------------------
/python/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.14)
 2 | 
 3 | project(pyalpaca CXX)
 4 | 
 5 | include(../cmake/project-is-top-level.cmake)
 6 | 
 7 | if(PROJECT_IS_TOP_LEVEL)
 8 |   find_package(alpaca REQUIRED)
 9 | endif()
10 | 
11 | if (NOT CMAKE_BUILD_TYPE MATCHES Debug)
12 |   add_definitions(-DNDEBUG)
13 | endif()
14 | 
15 | if(NOT CMAKE_BUILD_TYPE)
16 |   set(CMAKE_BUILD_TYPE Release)
17 | endif()
18 | 
19 | # Set default compile flags for GCC
20 | if(CMAKE_COMPILER_IS_GNUCXX)
21 |   set(CMAKE_CXX_FLAGS "-Wall -Wextra")
22 |   set(CMAKE_CXX_FLAGS_DEBUG "-g")
23 |   set(CMAKE_CXX_FLAGS_RELEASE "-O3")
24 | endif(CMAKE_COMPILER_IS_GNUCXX)
25 | 
26 | add_subdirectory(pybind11)
27 | pybind11_add_module(pyalpaca pyalpaca.cpp)
28 | target_link_libraries(pyalpaca PRIVATE alpaca::alpaca)


--------------------------------------------------------------------------------
/python/pyalpaca.cpp:
--------------------------------------------------------------------------------
1 | #include "python_deserialize_helper.h"
2 | #include "python_serialize_helper.h"
3 | 
4 | PYBIND11_MODULE(pyalpaca, m) {
5 |   m.def("serialize", &alpaca::python::do_serialize);
6 |   m.def("deserialize", &alpaca::python::do_deserialize);
7 | }


--------------------------------------------------------------------------------
/samples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_executable(fundamental_types fundamental_types.cpp)
 2 | target_link_libraries(fundamental_types PRIVATE alpaca::alpaca)
 3 | 
 4 | add_executable(arrays_vectors_strings arrays_vectors_strings.cpp)
 5 | target_link_libraries(arrays_vectors_strings PRIVATE alpaca::alpaca)
 6 | 
 7 | add_executable(maps_and_sets maps_and_sets.cpp)
 8 | target_link_libraries(maps_and_sets PRIVATE alpaca::alpaca)
 9 | 
10 | add_executable(nested_structures nested_structures.cpp)
11 | target_link_libraries(nested_structures PRIVATE alpaca::alpaca)
12 | 
13 | add_executable(optional_values optional_values.cpp)
14 | target_link_libraries(optional_values PRIVATE alpaca::alpaca)
15 | 
16 | add_executable(variant variant.cpp)
17 | target_link_libraries(variant PRIVATE alpaca::alpaca)
18 | 
19 | add_executable(unique_ptr unique_ptr.cpp)
20 | target_link_libraries(unique_ptr PRIVATE alpaca::alpaca)
21 | 
22 | add_executable(demo demo.cpp)
23 | target_link_libraries(demo PRIVATE alpaca::alpaca)
24 | 
25 | add_executable(write_file write_file.cpp)
26 | target_link_libraries(write_file PRIVATE alpaca::alpaca)
27 | 
28 | add_executable(chrono_duration chrono_duration.cpp)
29 | target_link_libraries(chrono_duration PRIVATE alpaca::alpaca)
30 | 
31 | add_executable(time_t time_t.cpp)
32 | target_link_libraries(time_t PRIVATE alpaca::alpaca)
33 | 


--------------------------------------------------------------------------------
/samples/arrays_vectors_strings.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     std::array<int, 3> a;
 7 |     std::vector<std::vector<float>> b;
 8 |     std::string c;
 9 |   };
10 | 
11 |   MyStruct s{{1, 2, 3}, {{3.14, 1.61}, {2.71, -1}}, {"Hello"}};
12 | 
13 |   // Serialize
14 |   std::vector<uint8_t> bytes;
15 |   auto bytes_written = alpaca::serialize(s, bytes); // 28 bytes
16 | 
17 |   // bytes:
18 |   // {
19 |   //   0x01 0x02 0x03            // array {1, 2, 3}
20 |   //   0x02                      // 2-element vector
21 |   //   0x02                      // 2-element (inner) vector
22 |   //   0xc3 0xf5 0x48 0x40       // vector[0][0] = 3.14
23 |   //   0x7b 0x14 0xce 0x3f       // vector[0][1] = 1.61
24 |   //   0x02                      // 2-element (inner) vector
25 |   //   0xa4 0x70 0x2d 0x40       // vector[1][0] = 2.71
26 |   //   0x00 0x00 0x80 0xbf       // vector[1][1] = -1
27 |   //   0x05                      // start of 5-byte string
28 |   //   0x48 0x65 0x6c 0x6c 0x6f  // string "Hello"
29 |   // }
30 | 
31 |   // Deserialize
32 |   std::error_code ec;
33 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
34 |   assert((bool)ec == false);
35 |   assert((recovered.a == std::array<int, 3>{1, 2, 3}));
36 |   assert((recovered.b ==
37 |           std::vector<std::vector<float>>{{3.14, 1.61}, {2.71, -1}}));
38 |   assert((recovered.c == std::string{"Hello"}));
39 | }


--------------------------------------------------------------------------------
/samples/chrono_duration.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | using namespace alpaca;
 3 | 
 4 | int main() {
 5 | 
 6 |   struct MyStruct {
 7 |     std::chrono::milliseconds period;
 8 |   };
 9 | 
10 |   MyStruct s{std::chrono::milliseconds{500}};
11 | 
12 |   // Serialize
13 |   std::vector<uint8_t> bytes;
14 |   auto bytes_written = alpaca::serialize(s, bytes);
15 | 
16 |   // Deserialize
17 |   std::error_code ec;
18 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
19 |   // period == 500ms
20 | }


--------------------------------------------------------------------------------
/samples/demo.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct Config {
 6 |     std::string device;
 7 |     std::pair<unsigned, unsigned> resolution;
 8 |     std::array<double, 9> K_matrix;
 9 |     std::vector<float> distortion_coeffients;
10 |     std::map<std::string, std::variant<uint16_t, std::string, bool>> parameters;
11 |   };
12 | 
13 |   // Construct the object
14 |   Config c{"/dev/video0",
15 |            {640, 480},
16 |            {223.28249888247538, 0.0, 152.30570853111396, 0.0, 223.8756535707556,
17 |             124.5606000035353, 0.0, 0.0, 1.0},
18 |            {-0.44158343539568284, 0.23861463831967872, 0.0016338407443826572,
19 |             0.0034950038632981604, -0.05239245892096022},
20 |            {{"start_server", bool{true}},
21 |             {"max_depth", uint16_t{5}},
22 |             {"model_path", std::string{"foo/bar.pt"}}}};
23 | 
24 |   // Serialize
25 |   std::vector<uint8_t> bytes;
26 |   auto bytes_written = alpaca::serialize(c, bytes);
27 | 
28 |   // Deserialize
29 |   std::error_code ec;
30 |   auto recovered = alpaca::deserialize<Config>(bytes, ec);
31 |   assert((bool)ec == false);
32 |   assert(recovered.device == std::string{"/dev/video0"});
33 |   assert((recovered.resolution == std::pair<unsigned, unsigned>{640, 480}));
34 |   assert((recovered.K_matrix ==
35 |           std::array<double, 9>{223.28249888247538, 0.0, 152.30570853111396,
36 |                                 0.0, 223.8756535707556, 124.5606000035353, 0.0,
37 |                                 0.0, 1.0}));
38 |   assert((recovered.distortion_coeffients ==
39 |           std::vector<float>{-0.44158343539568284, 0.23861463831967872,
40 |                              0.0016338407443826572, 0.0034950038632981604,
41 |                              -0.05239245892096022}));
42 |   assert((recovered.parameters ==
43 |           std::map<std::string, std::variant<uint16_t, std::string, bool>>{
44 |               {"start_server", bool{true}},
45 |               {"max_depth", uint16_t{5}},
46 |               {"model_path", std::string{"foo/bar.pt"}}}));
47 | }


--------------------------------------------------------------------------------
/samples/fundamental_types.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     char a;
 7 |     int b;
 8 |     uint64_t c;
 9 |     float d;
10 |     bool e;
11 |   };
12 | 
13 |   MyStruct s{'a', 5, 12345, 3.14f, true};
14 | 
15 |   // Serialize
16 |   std::vector<uint8_t> bytes;
17 |   auto bytes_written = alpaca::serialize(s, bytes); // 9 bytes
18 | 
19 |   // bytes:
20 |   // {
21 |   //   0x61                  // char 'a'
22 |   //   0x05                  // int 5
23 |   //   0xb9 0x60             // uint 12345
24 |   //   0xc3 0xf5 0x48 0x40   // float 3.14f
25 |   //   0x01                  // bool true
26 |   // }
27 | 
28 |   // Deserialize
29 |   std::error_code ec;
30 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
31 |   assert((bool)ec == false);
32 |   assert(recovered.a == 'a');
33 |   assert(recovered.b == 5);
34 |   assert(recovered.c == 12345);
35 |   assert(recovered.d == 3.14f);
36 |   assert(recovered.e == true);
37 | }


--------------------------------------------------------------------------------
/samples/maps_and_sets.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     std::map<std::string, std::tuple<uint8_t, uint8_t, uint8_t>> a;
 7 |     std::set<int> b;
 8 |   };
 9 | 
10 |   MyStruct s{{{"red", std::make_tuple(255, 0, 0)},
11 |               {"green", std::make_tuple(0, 255, 0)},
12 |               {"blue", std::make_tuple(0, 0, 255)}},
13 |              {1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 4}};
14 | 
15 |   // Serialize
16 |   std::vector<uint8_t> bytes;
17 |   auto bytes_written = alpaca::serialize(s, bytes); // 30 bytes
18 | 
19 |   // bytes:
20 |   // {
21 |   //   0x03                      // 3-element map
22 |   //   0x04                      // start of 4-byte string
23 |   //   0x62 0x6c 0x75 0x65       // string "blue"
24 |   //   0x00 0x00 0xff            // tuple {0, 0, 255}
25 |   //   0x05                      // start of 5-byte string
26 |   //   0x67 0x72 0x65 0x65 0x6e  // string "green"
27 |   //   0x00 0xff 0x00            // tuple {0, 255, 0}
28 |   //   0x03                      // 3-byte string
29 |   //   0x72 0x65 0x64            // string "red"
30 |   //   0xff 0x00 0x00            // tuple {255, 0, 0}
31 |   //   0x04                      // 4-element set
32 |   //   0x01 0x02 0x03 0x04       // set {1, 2, 3, 4}
33 |   // }
34 | 
35 |   // Deserialize
36 |   std::error_code ec;
37 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
38 |   assert((bool)ec == false);
39 |   assert((recovered.a ==
40 |           std::map<std::string, std::tuple<uint8_t, uint8_t, uint8_t>>{
41 |               {"red", std::make_tuple(255, 0, 0)},
42 |               {"green", std::make_tuple(0, 255, 0)},
43 |               {"blue", std::make_tuple(0, 0, 255)}}));
44 |   assert((recovered.b == std::set<int>{1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 4}));
45 | }


--------------------------------------------------------------------------------
/samples/nested_structures.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     struct gps {
 7 |       double latitude;
 8 |       double longitude;
 9 |     };
10 |     gps location;
11 | 
12 |     struct image {
13 |       uint16_t width;
14 |       uint16_t height;
15 |       std::string url;
16 | 
17 |       struct format {
18 |         enum class type { bayer_10bit, yuyv_422 };
19 |         type type;
20 |       };
21 |       format format;
22 |     };
23 |     image thumbnail;
24 |   };
25 | 
26 |   MyStruct s{{41.13, -73.70},
27 |              {480,
28 |               340,
29 |               "https://foo/bar/baz.jpg",
30 |               {MyStruct::image::format::type::yuyv_422}}};
31 | 
32 |   // Serialize
33 |   std::vector<uint8_t> bytes;
34 |   auto bytes_written = alpaca::serialize(s, bytes); // 45 bytes
35 | 
36 |   // bytes:
37 |   // {
38 |   //   0x71 0x3d 0x0a 0xd7 0xa3 0x90 0x44 0x40  // double 41.13
39 |   //   0xcd 0xcc 0xcc 0xcc 0xcc 0x6c 0x52 0xc0  // double -73.70
40 |   //   0xe0 0x01                                // uint 480
41 |   //   0x54 0x01                                // uint 340
42 |   //   0x17                                     // 23-byte string
43 |   //   0x68 0x74 0x74 0x70 0x73 0x3a 0x2f 0x2f  // "https://"
44 |   //   0x66 0x6f 0x6f 0x2f                      // "foo/"
45 |   //   0x62 0x61 0x72 0x2f                      // "bar/"
46 |   //   0x62 0x61 0x7a                           // "baz"
47 |   //   0x2e 0x6a 0x70 0x67                      // ".jpg"
48 |   //   0x01                                     // enum value 1
49 |   // }
50 | 
51 |   // Deserialize
52 |   std::error_code ec;
53 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
54 |   assert((bool)ec == false);
55 |   assert(recovered.location.latitude == 41.13);
56 |   assert(recovered.location.longitude == -73.70);
57 |   assert(recovered.thumbnail.width == 480);
58 |   assert(recovered.thumbnail.height == 340);
59 |   assert(recovered.thumbnail.url == std::string{"https://foo/bar/baz.jpg"});
60 |   assert(recovered.thumbnail.format.type ==
61 |          MyStruct::image::format::type::yuyv_422);
62 | }


--------------------------------------------------------------------------------
/samples/optional_values.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     std::optional<int> a;
 7 |     std::optional<float> b;
 8 |     std::optional<std::string> c;
 9 |     std::optional<std::vector<char>> d;
10 |   };
11 | 
12 |   MyStruct s{5, 3.14f, std::nullopt,
13 |              std::vector<char>{true, false, true, false}};
14 | 
15 |   // Serialize
16 |   std::vector<uint8_t> bytes;
17 |   auto bytes_written = alpaca::serialize<MyStruct, 4>(
18 |       s, bytes); // 14 bytes
19 |                  // ^^^^^^^^^^^
20 |                  //    specify the number of fields (4) in struct manually
21 |                  //    alpaca fails at correctly detecting this due to the
22 |                  //    nature of std::optional
23 | 
24 |   // bytes:
25 |   // {
26 |   //   0x01                    // optional has_value = true
27 |   //   0x05                    // value = 5
28 |   //   0x01                    // optional has_value = true
29 |   //   0xc3 0xf5 0x48 0x40     // value = 3.14f
30 |   //   0x00                    // optional has_value = false
31 |   //   0x01                    // optional has_value = true
32 |   //   0x04                    // 4-element vector
33 |   //   0x01 0x00 0x01 0x00     // {true, false, true, false}
34 |   // }
35 | 
36 |   // Deserialize
37 |   std::error_code ec;
38 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
39 |   assert((bool)ec == false);
40 |   assert(recovered.a.value() == 5);
41 |   assert(recovered.b.value() == 3.14f);
42 |   assert(recovered.c.has_value() == false);
43 |   assert((recovered.d.value() == std::vector<char>{true, false, true, false}));
44 | }


--------------------------------------------------------------------------------
/samples/pyalpaca_demo.py:
--------------------------------------------------------------------------------
 1 | import pyalpaca
 2 | 
 3 | # Create format string
 4 | format = '?cifs[i][[d]][3c]{c:i}{I}(cif)(s(dI))'
 5 | 
 6 | # Construct object
 7 | object = [
 8 |     False, 
 9 |     'a', 
10 |     5, 
11 |     3.14, 
12 |     "Hello World!",
13 |     [0, 1, 2, 3], 
14 |     [[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]],
15 |     ['a', 'b', 'c'],
16 |     {'a': 5, 'b': 19},
17 |     {1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 6},
18 |     ('a', 45, 2.718),
19 |     ("Hello", (39.456, 21))
20 | ]
21 | 
22 | # Serialize
23 | bytes = pyalpaca.serialize(format, object)
24 | 
25 | # Print it
26 | print("Bytes:")
27 | hex_values = ["0x{:02x}".format(b) for b in bytes]
28 | for i, h in enumerate(hex_values):
29 |     if i > 0 and i % 8 == 0:
30 |         print("\n  ", end="")
31 |     elif i == 0 and i % 8 == 0:
32 |         print("  ", end="")
33 |     print(h, end=" ")
34 | print()
35 | 
36 | # Deserialize
37 | recovered = pyalpaca.deserialize(format, bytes)
38 | 
39 | # Print it
40 | print("\nDeserialized:\n[ ")
41 | for i in recovered:
42 |     print("    " + str(i) + ",")
43 | print("]")


--------------------------------------------------------------------------------
/samples/time_t.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | using namespace alpaca;
 3 | 
 4 | int main() {
 5 | 
 6 |   struct MyStruct {
 7 |     std::time_t timestamp;
 8 |   };
 9 | 
10 |   auto timestamp =
11 |       std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
12 | 
13 |   MyStruct s{timestamp};
14 | 
15 |   constexpr auto OPTIONS = options::big_endian | options::fixed_length_encoding;
16 | 
17 |   // Serialize
18 |   std::vector<uint8_t> bytes;
19 |   auto bytes_written = alpaca::serialize<OPTIONS>(s, bytes);
20 | 
21 |   // bytes: {0x00 0x00 0x00 0x00 0x63 0x13 0xeb 0x21}
22 | 
23 |   // Deserialize
24 |   std::error_code ec;
25 |   auto recovered = alpaca::deserialize<OPTIONS, MyStruct>(bytes, ec);
26 | 
27 |   // timestamp: 1662249761
28 |   //
29 |   // Human time:
30 |   // GMT: Sunday, September 4, 2022 12:02:41 AM
31 | }


--------------------------------------------------------------------------------
/samples/unique_ptr.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
 4 | 
 5 | template <class T> struct Node {
 6 |   T data;
 7 |   std::unique_ptr<Node<T>> left;
 8 |   std::unique_ptr<Node<T>> right;
 9 | };
10 | 
11 | template <class T>
12 | auto make_node(T const &value, std::unique_ptr<Node<T>> lhs = nullptr,
13 |                std::unique_ptr<Node<T>> rhs = nullptr) {
14 |   return std::unique_ptr<Node<T>>(
15 |       new Node<T>{value, std::move(lhs), std::move(rhs)});
16 | }
17 | 
18 | int main() {
19 | 
20 |   /*
21 |     Binary Tree:
22 |           5
23 |          / \
24 |         3   4
25 |        / \
26 |       1   2
27 |   */
28 | 
29 |   auto const root =
30 |       make_node(5, make_node(3, make_node(1), make_node(2)), make_node(4));
31 | 
32 |   // serialize
33 |   std::vector<uint8_t> bytes;
34 |   auto bytes_written = alpaca::serialize<Node<int>>(*root, bytes); // 15 bytes
35 | 
36 |   // bytes:
37 |   // {
38 |   //   0x05 // root = 5
39 |   //   0x01 // 5.has_left = true
40 |   //   0x03 // 5.left = 3
41 |   //   0x01 // 3.has_left = true
42 |   //   0x01 // 3.left = 1
43 |   //   0x00 // 1.left = null
44 |   //   0x00 // 1.right = null
45 |   //   0x01 // 3.has_right = true
46 |   //   0x02 // 3.right = 2
47 |   //   0x00 // 2.has_left = false
48 |   //   0x00 // 2.has_right = false
49 |   //   0x01 // 5.has_right = true
50 |   //   0x04 // 5.right = 4
51 |   //   0x00 // 4.has_left = false
52 |   //   0x00 // 4.has_right = false
53 |   // }
54 | 
55 |   std::error_code ec;
56 |   auto tree = alpaca::deserialize<Node<int>>(bytes, ec);
57 |   assert((bool)ec == false);
58 |   assert((bool)ec == false);
59 |   assert(tree.data == 5);
60 |   auto &left_subtree_0 = *(tree.left);
61 |   assert(left_subtree_0.data == 3);
62 |   const auto &right_subtree_0 = *(tree.right);
63 |   assert(right_subtree_0.data == 4);
64 |   assert(right_subtree_0.left == nullptr);
65 |   assert(right_subtree_0.right == nullptr);
66 |   const auto &left_subtree_1 = *(left_subtree_0.left);
67 |   assert(left_subtree_1.data == 1);
68 |   assert(left_subtree_1.left == nullptr);
69 |   assert(left_subtree_1.right == nullptr);
70 |   const auto &right_subtree_1 = *(left_subtree_0.right);
71 |   assert(right_subtree_1.data == 2);
72 |   assert(right_subtree_1.left == nullptr);
73 |   assert(right_subtree_1.right == nullptr);
74 | }
75 | 
76 | #else
77 | 
78 | int main() {}
79 | 
80 | #endif


--------------------------------------------------------------------------------
/samples/variant.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | 
 3 | int main() {
 4 | 
 5 |   struct MyStruct {
 6 |     std::map<std::string, std::variant<uint16_t, std::string, bool,
 7 |                                        std::vector<std::string>>>
 8 |         value;
 9 |   };
10 | 
11 |   MyStruct s{{{"keepalive", true},
12 |               {"port", uint16_t{8080}},
13 |               {"ip_address", std::string{"192.168.8.1"}},
14 |               {"subscriptions",
15 |                std::vector<std::string>{"motor_state", "battery_state"}}}};
16 | 
17 |   // serialize
18 |   std::vector<uint8_t> bytes;
19 |   auto bytes_written = alpaca::serialize(s, bytes); // 87 bytes
20 | 
21 |   // deserialize
22 |   std::error_code ec;
23 |   auto recovered = alpaca::deserialize<MyStruct>(bytes, ec);
24 |   assert((bool)ec == false);
25 |   assert((recovered.value == std::map < std::string,
26 |           std::variant<uint16_t, std::string, bool, std::vector<std::string>>{
27 |               {"keepalive", true},
28 |               {"port", uint16_t{8080}},
29 |               {"ip_address", std::string{"192.168.8.1"}},
30 |               {"subscriptions",
31 |                std::vector<std::string>{"motor_state", "battery_state"}}}));
32 | }
33 | 


--------------------------------------------------------------------------------
/samples/write_file.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <filesystem>
 3 | using namespace alpaca;
 4 | 
 5 | struct GameState {
 6 |   int a;
 7 |   bool b;
 8 |   char c;
 9 |   std::string d;
10 |   std::vector<uint64_t> e;
11 |   std::map<std::string, std::array<uint8_t, 3>> f;
12 | };
13 | 
14 | int main() {
15 | 
16 |   GameState s{5,
17 |               true,
18 |               'a',
19 |               "Hello World",
20 |               {6, 5, 4, 3, 2, 1},
21 |               {{"abc", {1, 2, 3}}, {"def", {4, 5, 6}}}};
22 | 
23 |   const auto filename = "savefile.bin";
24 | 
25 |   {
26 |     // Serialize to file
27 |     std::ofstream os;
28 |     os.open(filename, std::ios::out | std::ios::binary);
29 |     auto bytes_written = serialize(s, os);
30 |     os.close();
31 | 
32 |     assert(bytes_written == 37);
33 |     assert(std::filesystem::file_size(filename) == 37);
34 |   }
35 | 
36 |   {
37 |     // Deserialize from file
38 |     auto size = std::filesystem::file_size(filename);
39 |     std::error_code ec;
40 |     std::ifstream is;
41 |     is.open(filename, std::ios::in | std::ios::binary);
42 |     auto recovered = deserialize<GameState>(is, size, ec);
43 |     is.close();
44 | 
45 |     assert(recovered.a == s.a);
46 |     assert(recovered.b == s.b);
47 |     assert(recovered.c == s.c);
48 |     assert(recovered.d == s.d);
49 |     assert(recovered.e == s.e);
50 |     assert(recovered.f == s.f);
51 |   }
52 | 
53 |   // delete file
54 |   // std::filesystem::remove(filename);
55 | }
56 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.6)
 2 | project(alpaca)
 3 | 
 4 | if(MSVC)
 5 |   # Force to always compile with W4
 6 |   if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
 7 |     string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 8 |   else()
 9 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
10 |   endif()
11 | elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
12 |   # Update if necessary
13 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic")
14 | endif()
15 | 
16 | if(NOT CMAKE_BUILD_TYPE)
17 |   set(CMAKE_BUILD_TYPE Release)
18 | endif()
19 | 
20 | # Disable deprecation for windows
21 | if (WIN32)
22 | 	add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
23 | endif()
24 | 
25 | # ALPACA executable
26 | file(GLOB ALPACA_TEST_SOURCES *.cpp)
27 | 
28 | set_source_files_properties(main.cpp
29 |     PROPERTIES
30 |     COMPILE_DEFINITIONS DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN)
31 | ADD_EXECUTABLE(ALPACA ${ALPACA_TEST_SOURCES})
32 | INCLUDE_DIRECTORIES("../include" ".")
33 | set_target_properties(ALPACA PROPERTIES OUTPUT_NAME tests)
34 | set_property(TARGET ALPACA PROPERTY CXX_STANDARD 17)
35 | 
36 | # Set ${PROJECT_NAME} as the startup project
37 | set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ALPACA)


--------------------------------------------------------------------------------
/test/main.cpp:
--------------------------------------------------------------------------------
1 | #include <doctest.hpp>


--------------------------------------------------------------------------------
/test/test_backwards_compatibility.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Backwards Compatibility (new field added in struct)" *
 8 |           test_suite("backwards_compatibility")) {
 9 | 
10 |   std::vector<uint8_t> bytes;
11 |   {
12 |     // client side is updated to use
13 |     // a new structure
14 |     struct my_struct {
15 |       int old_field_1;
16 |       float old_field_2;
17 |       std::string new_field_1;
18 |     };
19 | 
20 |     my_struct s{5, 3.14f, "Hello"};
21 |     serialize(s, bytes);
22 |   }
23 | 
24 |   {
25 |     // server side is still compiled to
26 |     // deserialize the older version of
27 |     // the struct
28 |     struct my_struct {
29 |       int old_field_1;
30 |       float old_field_2;
31 |     };
32 |     std::error_code ec;
33 |     auto s = deserialize<my_struct>(bytes, ec);
34 |     REQUIRE((bool)ec == false);
35 |     REQUIRE(s.old_field_1 == 5);
36 |     REQUIRE(s.old_field_2 == 3.14f);
37 |   }
38 | }


--------------------------------------------------------------------------------
/test/test_deserialize_bool.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize bool (true)" * test_suite("bool")) {
 8 |   struct my_struct {
 9 |     bool value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   {
15 |     my_struct s{true};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value == true);
24 |   }
25 | }
26 | 
27 | TEST_CASE("Deserialize bool (true)" * test_suite("bool")) {
28 |   struct my_struct {
29 |     bool value;
30 |   };
31 | 
32 |   std::vector<uint8_t> bytes;
33 | 
34 |   {
35 |     my_struct s{false};
36 |     serialize(s, bytes);
37 |   }
38 | 
39 |   {
40 |     std::error_code ec;
41 |     auto result = deserialize<my_struct>(bytes, ec);
42 |     REQUIRE((bool)ec == false);
43 |     REQUIRE(result.value == false);
44 |   }
45 | }


--------------------------------------------------------------------------------
/test/test_deserialize_bool_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize bool (true)" * test_suite("bool")) {
 8 |   struct my_struct {
 9 |     bool value;
10 |   };
11 | 
12 |   std::array<uint8_t, 1> bytes;
13 | 
14 |   {
15 |     my_struct s{true};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value == true);
24 |   }
25 | }
26 | 
27 | TEST_CASE("Deserialize bool (true)" * test_suite("bool")) {
28 |   struct my_struct {
29 |     bool value;
30 |   };
31 | 
32 |   std::array<uint8_t, 1> bytes;
33 | 
34 |   {
35 |     my_struct s{false};
36 |     serialize(s, bytes);
37 |   }
38 | 
39 |   {
40 |     std::error_code ec;
41 |     auto result = deserialize<my_struct>(bytes, ec);
42 |     REQUIRE((bool)ec == false);
43 |     REQUIRE(result.value == false);
44 |   }
45 | }


--------------------------------------------------------------------------------
/test/test_deserialize_chrono_duration.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize chrono duration" * test_suite("chrono_duration")) {
 8 |   struct my_struct {
 9 |     std::chrono::milliseconds period;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{std::chrono::milliseconds{500}};
17 |     serialize(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     std::error_code ec;
23 |     auto object = deserialize<my_struct>(bytes, ec);
24 |     REQUIRE((bool)ec == false);
25 |     REQUIRE(object.period.count() == 500);
26 |   }
27 | }


--------------------------------------------------------------------------------
/test/test_deserialize_chrono_duration_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize chrono duration" * test_suite("chrono_duration")) {
 8 |   struct my_struct {
 9 |     std::chrono::milliseconds period;
10 |   };
11 | 
12 |   std::array<uint8_t, 5> bytes;
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{std::chrono::milliseconds{500}};
17 |     serialize(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     std::error_code ec;
23 |     auto object = deserialize<my_struct>(bytes, ec);
24 |     REQUIRE((bool)ec == false);
25 |     REQUIRE(object.period.count() == 500);
26 |   }
27 | }


--------------------------------------------------------------------------------
/test/test_deserialize_deque.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize deque<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::deque<char> values;
 10 |   };
 11 | 
 12 |   std::vector<uint8_t> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     serialize(s, bytes);
 17 |     REQUIRE(bytes.size() == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::deque<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize deque<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::deque<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::vector<uint8_t> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     serialize(s, bytes);
 38 |     REQUIRE(bytes.size() == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::deque<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize deque<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::deque<int> values;
 52 |   };
 53 | 
 54 |   std::vector<uint8_t> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     serialize(s, bytes);
 59 |     REQUIRE(bytes.size() == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::deque<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize deque<deque<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::deque<std::deque<char>> values;
 73 |   };
 74 | 
 75 |   std::vector<uint8_t> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::deque<std::deque<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize deque<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::deque<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::deque<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::vector<uint8_t> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::deque<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     auto front = result.nested_values.front();
116 |     REQUIRE(front.value == 1);
117 |     result.nested_values.pop_front();
118 |     front = result.nested_values.front();
119 |     REQUIRE(front.value == 2);
120 |     result.nested_values.pop_front();
121 |     front = result.nested_values.front();
122 |     REQUIRE(front.value == 3);
123 |     result.nested_values.pop_front();
124 |   }
125 | }


--------------------------------------------------------------------------------
/test/test_deserialize_deque_from_array.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize deque<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::deque<char> values;
 10 |   };
 11 | 
 12 |   std::array<uint8_t, 20> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     auto bytes_written = serialize(s, bytes);
 17 |     REQUIRE(bytes_written == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::deque<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize deque<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::deque<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::array<uint8_t, 20> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     auto bytes_written = serialize(s, bytes);
 38 |     REQUIRE(bytes_written == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::deque<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize deque<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::deque<int> values;
 52 |   };
 53 | 
 54 |   std::array<uint8_t, 20> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     auto bytes_written = serialize(s, bytes);
 59 |     REQUIRE(bytes_written == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::deque<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize deque<deque<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::deque<std::deque<char>> values;
 73 |   };
 74 | 
 75 |   std::array<uint8_t, 20> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::deque<std::deque<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize deque<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::deque<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::deque<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::array<uint8_t, 32> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::deque<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     auto front = result.nested_values.front();
116 |     REQUIRE(front.value == 1);
117 |     result.nested_values.pop_front();
118 |     front = result.nested_values.front();
119 |     REQUIRE(front.value == 2);
120 |     result.nested_values.pop_front();
121 |     front = result.nested_values.front();
122 |     REQUIRE(front.value == 3);
123 |     result.nested_values.pop_front();
124 |   }
125 | }


--------------------------------------------------------------------------------
/test/test_deserialize_enum_class.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize enum class" * test_suite("enum_class")) {
 8 |   struct my_struct {
 9 |     enum class color { red, blue, green };
10 |     color value;
11 |   };
12 | 
13 |   std::vector<uint8_t> bytes;
14 | 
15 |   {
16 |     my_struct s{my_struct::color::blue};
17 |     serialize(s, bytes);
18 |   }
19 | 
20 |   {
21 |     std::error_code ec;
22 |     auto result = deserialize<my_struct>(bytes, ec);
23 |     REQUIRE((bool)ec == false);
24 |     REQUIRE(result.value == my_struct::color::blue);
25 |   }
26 | }


--------------------------------------------------------------------------------
/test/test_deserialize_enum_class_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize enum class" * test_suite("enum_class")) {
 8 |   struct my_struct {
 9 |     enum class color { red, blue, green };
10 |     color value;
11 |   };
12 | 
13 |   std::array<uint8_t, 10> bytes;
14 | 
15 |   {
16 |     my_struct s{my_struct::color::blue};
17 |     serialize(s, bytes);
18 |   }
19 | 
20 |   {
21 |     std::error_code ec;
22 |     auto result = deserialize<my_struct>(bytes, ec);
23 |     REQUIRE((bool)ec == false);
24 |     REQUIRE(result.value == my_struct::color::blue);
25 |   }
26 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_crc32.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize crc32 error - invalid_argument" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{5};
17 |     serialize<options::with_checksum>(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     auto received = std::vector<uint8_t>(bytes.begin(), bytes.begin() + 2);
23 |     // not enough bytes in input
24 |     // CRC32 check requires at least 4 bytes
25 | 
26 |     std::error_code ec;
27 |     deserialize<options::with_checksum, my_struct>(received, ec);
28 |     REQUIRE((bool)ec == true);
29 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
30 |   }
31 | }
32 | 
33 | TEST_CASE("Deserialize crc32 error - bad_message" * test_suite("crc32")) {
34 |   struct my_struct {
35 |     int value;
36 |   };
37 | 
38 |   std::vector<uint8_t> bytes;
39 | 
40 |   // serialize
41 |   {
42 |     my_struct s{5};
43 |     serialize<options::with_checksum>(s, bytes);
44 |   }
45 | 
46 |   // deserialize
47 |   {
48 |     auto received = std::vector<uint8_t>{0x05, 0x01, 0x02, 0x03, 0x04};
49 |     //                                        ^^^^^^^^^^^^^^^^^^^^^^ bad crc
50 | 
51 |     std::error_code ec;
52 |     deserialize<options::with_checksum, my_struct>(received, ec);
53 |     REQUIRE((bool)ec == true);
54 |     REQUIRE(ec.value() == static_cast<int>(std::errc::bad_message));
55 |   }
56 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_crc32_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize crc32 error - invalid_argument" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::array<uint8_t, 5> bytes;
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{5};
17 |     serialize<options::with_checksum>(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     auto received = std::array<uint8_t, 2>{0};
23 |     received[0] = bytes[0];
24 |     received[1] = bytes[1];
25 |     // not enough bytes in input
26 |     // CRC32 check requires at least 4 bytes
27 | 
28 |     std::error_code ec;
29 |     deserialize<options::with_checksum, my_struct>(received, ec);
30 |     REQUIRE((bool)ec == true);
31 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
32 |   }
33 | }
34 | 
35 | TEST_CASE("Deserialize crc32 error - bad_message" * test_suite("crc32")) {
36 |   struct my_struct {
37 |     int value;
38 |   };
39 | 
40 |   std::array<uint8_t, 5> bytes;
41 | 
42 |   // serialize
43 |   {
44 |     my_struct s{5};
45 |     serialize<options::with_checksum>(s, bytes);
46 |   }
47 | 
48 |   // deserialize
49 |   {
50 |     auto received = std::array<uint8_t, 5>{0x05, 0x01, 0x02, 0x03, 0x04};
51 |     //                                           ^^^^^^^^^^^^^^^^^^^^^^ bad crc
52 | 
53 |     std::error_code ec;
54 |     deserialize<options::with_checksum, my_struct>(received, ec);
55 |     REQUIRE((bool)ec == true);
56 |     REQUIRE(ec.value() == static_cast<int>(std::errc::bad_message));
57 |   }
58 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_set.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize set<int> error - size value_too_large" *
 8 |           test_suite("vector")) {
 9 |   struct my_struct {
10 |     std::set<int> values;
11 |   };
12 | 
13 |   {
14 |     auto bytes = std::vector<uint8_t>{0xff, 0x01, 0x02, 0x03};
15 | 
16 |     // size is 0xff which is too large since there are only 3 values
17 |     // left in the buffer
18 | 
19 |     std::error_code ec;
20 |     auto result = deserialize<my_struct>(bytes, ec);
21 |     REQUIRE((bool)ec == true);
22 |     REQUIRE(ec.value() == static_cast<int>(std::errc::value_too_large));
23 |   }
24 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_set_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize set<int> error - size value_too_large" *
 8 |           test_suite("array")) {
 9 |   struct my_struct {
10 |     std::set<int> values;
11 |   };
12 | 
13 |   {
14 |     auto bytes = std::array<uint8_t, 4>{0xff, 0x01, 0x02, 0x03};
15 | 
16 |     // size is 0xff which is too large since there are only 3 values
17 |     // left in the buffer
18 | 
19 |     std::error_code ec;
20 |     auto result = deserialize<my_struct>(bytes, ec);
21 |     REQUIRE((bool)ec == true);
22 |     REQUIRE(ec.value() == static_cast<int>(std::errc::value_too_large));
23 |   }
24 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_vector.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize vector<int> error - size value_too_large" *
 8 |           test_suite("vector")) {
 9 |   struct my_struct {
10 |     std::vector<int> values;
11 |   };
12 | 
13 |   {
14 |     auto bytes = std::vector<uint8_t>{0xff, 0x01, 0x02, 0x03};
15 | 
16 |     // size is 0xff which is too large since there are only 3 values
17 |     // left in the buffer
18 | 
19 |     std::error_code ec;
20 |     auto result = deserialize<my_struct>(bytes, ec);
21 |     REQUIRE((bool)ec == true);
22 |     REQUIRE(ec.value() == static_cast<int>(std::errc::value_too_large));
23 |   }
24 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_vector_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize vector<int> error - size value_too_large" *
 8 |           test_suite("vector")) {
 9 |   struct my_struct {
10 |     std::vector<int> values;
11 |   };
12 | 
13 |   {
14 |     auto bytes = std::array<uint8_t, 4>{0xff, 0x01, 0x02, 0x03};
15 | 
16 |     // size is 0xff which is too large since there are only 3 values
17 |     // left in the buffer
18 | 
19 |     std::error_code ec;
20 |     auto result = deserialize<my_struct>(bytes, ec);
21 |     REQUIRE((bool)ec == true);
22 |     REQUIRE(ec.value() == static_cast<int>(std::errc::value_too_large));
23 |   }
24 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_version.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int into another struct { uint16_t }" *
 8 |           test_suite("version")) {
 9 | 
10 |   std::vector<uint8_t> bytes;
11 | 
12 |   {
13 |     struct my_struct {
14 |       int value;
15 |     };
16 |     my_struct s{5};
17 |     serialize<options::with_version>(s, bytes);
18 |   }
19 | 
20 |   {
21 |     struct my_struct {
22 |       uint16_t value;
23 |     };
24 |     std::error_code ec;
25 |     deserialize<options::with_version, my_struct>(bytes, ec);
26 |     REQUIRE((bool)ec == true);
27 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
28 |   }
29 | }
30 | 
31 | TEST_CASE("Deserialize int into struct { int,int,int }" *
32 |           test_suite("version")) {
33 | 
34 |   std::vector<uint8_t> bytes;
35 | 
36 |   {
37 |     struct my_struct {
38 |       int value;
39 |     };
40 |     my_struct s{5};
41 |     serialize<options::with_version>(s, bytes);
42 |   }
43 | 
44 |   {
45 |     struct my_struct {
46 |       int a;
47 |       int b;
48 |       int c;
49 |     };
50 |     std::error_code ec;
51 |     deserialize<options::with_version, my_struct>(bytes, ec);
52 |     REQUIRE((bool)ec == true);
53 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
54 |   }
55 | }
56 | 
57 | TEST_CASE("Deserialize vector<int> into struct { vector<float> }" *
58 |           test_suite("version")) {
59 | 
60 |   std::vector<uint8_t> bytes;
61 | 
62 |   {
63 |     struct my_struct {
64 |       std::vector<int> value;
65 |     };
66 |     my_struct s{{1, 2, 3, 4, 5}};
67 |     serialize<options::with_version>(s, bytes);
68 |   }
69 | 
70 |   {
71 |     struct my_struct {
72 |       std::vector<float> value;
73 |     };
74 |     std::error_code ec;
75 |     deserialize<options::with_version, my_struct>(bytes, ec);
76 |     REQUIRE((bool)ec == true);
77 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
78 |   }
79 | }


--------------------------------------------------------------------------------
/test/test_deserialize_error_version_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int into another struct { uint16_t }" *
 8 |           test_suite("version")) {
 9 | 
10 |   std::array<uint8_t, 10> bytes;
11 | 
12 |   {
13 |     struct my_struct {
14 |       int value;
15 |     };
16 |     my_struct s{5};
17 |     serialize<options::with_version>(s, bytes);
18 |   }
19 | 
20 |   {
21 |     struct my_struct {
22 |       uint16_t value;
23 |     };
24 |     std::error_code ec;
25 |     deserialize<options::with_version, my_struct>(bytes, ec);
26 |     REQUIRE((bool)ec == true);
27 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
28 |   }
29 | }
30 | 
31 | TEST_CASE("Deserialize int into struct { int,int,int }" *
32 |           test_suite("version")) {
33 | 
34 |   std::array<uint8_t, 10> bytes;
35 | 
36 |   {
37 |     struct my_struct {
38 |       int value;
39 |     };
40 |     my_struct s{5};
41 |     serialize<options::with_version>(s, bytes);
42 |   }
43 | 
44 |   {
45 |     struct my_struct {
46 |       int a;
47 |       int b;
48 |       int c;
49 |     };
50 |     std::error_code ec;
51 |     deserialize<options::with_version, my_struct>(bytes, ec);
52 |     REQUIRE((bool)ec == true);
53 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
54 |   }
55 | }
56 | 
57 | TEST_CASE("Deserialize vector<int> into struct { vector<float> }" *
58 |           test_suite("version")) {
59 | 
60 |   std::array<uint8_t, 10> bytes;
61 | 
62 |   {
63 |     struct my_struct {
64 |       std::vector<int> value;
65 |     };
66 |     my_struct s{{1, 2, 3, 4, 5}};
67 |     serialize<options::with_version>(s, bytes);
68 |   }
69 | 
70 |   {
71 |     struct my_struct {
72 |       std::vector<float> value;
73 |     };
74 |     std::error_code ec;
75 |     deserialize<options::with_version, my_struct>(bytes, ec);
76 |     REQUIRE((bool)ec == true);
77 |     REQUIRE(ec.value() == static_cast<int>(std::errc::invalid_argument));
78 |   }
79 | }


--------------------------------------------------------------------------------
/test/test_deserialize_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize float" * test_suite("float")) {
 8 |   struct my_struct {
 9 |     float value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 |   {
14 |     my_struct s{3.14f};
15 |     serialize(s, bytes);
16 |   }
17 |   {
18 |     std::error_code ec;
19 |     auto result = deserialize<my_struct>(bytes, ec);
20 |     REQUIRE((bool)ec == false);
21 |     REQUIRE(result.value == 3.14f);
22 |   }
23 | }
24 | 
25 | TEST_CASE("Deserialize double" * test_suite("float")) {
26 |   struct my_struct {
27 |     double value;
28 |   };
29 | 
30 |   std::vector<uint8_t> bytes;
31 |   {
32 |     my_struct s{2.71828};
33 |     serialize(s, bytes);
34 |   }
35 |   {
36 |     std::error_code ec;
37 |     auto result = deserialize<my_struct>(bytes, ec);
38 |     REQUIRE((bool)ec == false);
39 |     REQUIRE(result.value == 2.71828);
40 |   }
41 | }


--------------------------------------------------------------------------------
/test/test_deserialize_float_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize float" * test_suite("float")) {
 8 |   struct my_struct {
 9 |     float value;
10 |   };
11 | 
12 |   std::array<uint8_t, 10> bytes;
13 |   {
14 |     my_struct s{3.14f};
15 |     serialize(s, bytes);
16 |   }
17 |   {
18 |     std::error_code ec;
19 |     auto result = deserialize<my_struct>(bytes, ec);
20 |     REQUIRE((bool)ec == false);
21 |     REQUIRE(result.value == 3.14f);
22 |   }
23 | }
24 | 
25 | TEST_CASE("Deserialize double" * test_suite("float")) {
26 |   struct my_struct {
27 |     double value;
28 |   };
29 | 
30 |   std::array<uint8_t, 10> bytes;
31 |   {
32 |     my_struct s{2.71828};
33 |     serialize(s, bytes);
34 |   }
35 |   {
36 |     std::error_code ec;
37 |     auto result = deserialize<my_struct>(bytes, ec);
38 |     REQUIRE((bool)ec == false);
39 |     REQUIRE(result.value == 2.71828);
40 |   }
41 | }


--------------------------------------------------------------------------------
/test/test_deserialize_from_carray.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize from C-array" * test_suite("carray")) {
 8 |   uint8_t buf[10];
 9 | 
10 |   struct Foo {
11 |     int value;
12 |   };
13 |   Foo f{5};
14 | 
15 |   auto bytes_written = alpaca::serialize(f, buf);
16 |   REQUIRE(bytes_written == 1);
17 |   REQUIRE(buf[0] == 0x05);
18 | 
19 |   std::error_code ec;
20 |   auto foo = alpaca::deserialize<Foo>(buf, bytes_written, ec);
21 |   REQUIRE((bool)ec == false);
22 |   REQUIRE(foo.value == 5);
23 | }
24 | 
25 | TEST_CASE("Deserialize from C-array with version and checksum" *
26 |           test_suite("carray")) {
27 |   uint8_t buf[10];
28 | 
29 |   struct Foo {
30 |     int value;
31 |   };
32 |   Foo f{5};
33 | 
34 |   constexpr auto OPTIONS =
35 |       alpaca::options::with_version | alpaca::options::with_checksum;
36 |   auto bytes_written = alpaca::serialize<OPTIONS>(f, buf);
37 |   REQUIRE(bytes_written == 9);
38 |   REQUIRE(buf[4] == 0x05);
39 | 
40 |   std::error_code ec;
41 |   auto foo = alpaca::deserialize<OPTIONS, Foo>(buf, bytes_written, ec);
42 |   REQUIRE((bool)ec == false);
43 |   REQUIRE(foo.value == 5);
44 | }


--------------------------------------------------------------------------------
/test/test_deserialize_from_ifstream.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | #include <filesystem>
 4 | using namespace alpaca;
 5 | 
 6 | using doctest::test_suite;
 7 | 
 8 | TEST_CASE("Deserialize complex struct from ifstream" * test_suite("fstream")) {
 9 |   struct my_struct {
10 |     int a;
11 |     bool b;
12 |     char c;
13 |     std::string d;
14 |     std::vector<uint64_t> e;
15 |     std::map<std::string, std::array<uint8_t, 3>> f;
16 |   };
17 | 
18 |   my_struct s{5,
19 |               true,
20 |               'a',
21 |               "Hello World",
22 |               {6, 5, 4, 3, 2, 1},
23 |               {{"abc", {1, 2, 3}}, {"def", {4, 5, 6}}}};
24 | 
25 |   {
26 |     // Serialize to file
27 |     std::ofstream os;
28 |     os.open("tmp1.bin", std::ios::out | std::ios::binary);
29 |     auto bytes_written = serialize(s, os);
30 |     os.close();
31 |     REQUIRE(bytes_written == 37);
32 |     REQUIRE(std::filesystem::file_size("tmp1.bin") == 37);
33 |   }
34 | 
35 |   {
36 |     // Deserialize from file
37 |     auto size = std::filesystem::file_size("tmp1.bin");
38 |     std::error_code ec;
39 |     std::ifstream is;
40 |     is.open("tmp1.bin", std::ios::in | std::ios::binary);
41 |     auto recovered = deserialize<my_struct>(is, size, ec);
42 |     is.close();
43 |     REQUIRE(recovered.a == s.a);
44 |     REQUIRE(recovered.b == s.b);
45 |     REQUIRE(recovered.c == s.c);
46 |     REQUIRE(recovered.d == s.d);
47 |     REQUIRE(recovered.e == s.e);
48 |     REQUIRE(recovered.f == s.f);
49 |     std::filesystem::remove("tmp1.bin");
50 |   }
51 | }
52 | 
53 | TEST_CASE("Deserialize complex struct from ifstream with options" *
54 |           test_suite("fstream")) {
55 |   struct my_struct {
56 |     int a;
57 |     bool b;
58 |     char c;
59 |     std::string d;
60 |     std::vector<uint64_t> e;
61 |     std::map<std::string, std::array<uint8_t, 3>> f;
62 |   };
63 | 
64 |   my_struct s{5,
65 |               true,
66 |               'a',
67 |               "Hello World",
68 |               {6, 5, 4, 3, 2, 1},
69 |               {{"abc", {1, 2, 3}}, {"def", {4, 5, 6}}}};
70 | 
71 |   constexpr auto OPTIONS = options::big_endian | options::fixed_length_encoding;
72 |   {
73 |     // Serialize to file
74 |     std::ofstream os;
75 |     os.open("tmp2.bin", std::ios::out | std::ios::binary);
76 |     auto bytes_written = serialize<OPTIONS>(s, os);
77 |     os.close();
78 |     constexpr auto expected = 93 + sizeof(alpaca::detail::size_t_serialized_type);
79 |     REQUIRE(bytes_written == expected);
80 |     REQUIRE(std::filesystem::file_size("tmp2.bin") == expected);
81 |   }
82 | 
83 |   {
84 |     // Deserialize from file
85 |     auto size = std::filesystem::file_size("tmp2.bin");
86 |     std::error_code ec;
87 |     std::ifstream is;
88 |     is.open("tmp2.bin", std::ios::in | std::ios::binary);
89 |     auto recovered = deserialize<OPTIONS, my_struct>(is, size, ec);
90 |     is.close();
91 |     REQUIRE(recovered.a == s.a);
92 |     REQUIRE(recovered.b == s.b);
93 |     REQUIRE(recovered.c == s.c);
94 |     REQUIRE(recovered.d == s.d);
95 |     REQUIRE(recovered.e == s.e);
96 |     REQUIRE(recovered.f == s.f);
97 |     std::filesystem::remove("tmp2.bin");
98 |   }
99 | }


--------------------------------------------------------------------------------
/test/test_deserialize_list.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize list<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::list<char> values;
 10 |   };
 11 | 
 12 |   std::vector<uint8_t> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     serialize(s, bytes);
 17 |     REQUIRE(bytes.size() == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::list<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize list<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::list<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::vector<uint8_t> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     serialize(s, bytes);
 38 |     REQUIRE(bytes.size() == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::list<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize list<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::list<int> values;
 52 |   };
 53 | 
 54 |   std::vector<uint8_t> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     serialize(s, bytes);
 59 |     REQUIRE(bytes.size() == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::list<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize list<list<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::list<std::list<char>> values;
 73 |   };
 74 | 
 75 |   std::vector<uint8_t> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::list<std::list<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize list<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::list<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::list<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::vector<uint8_t> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::list<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     auto front = result.nested_values.front();
116 |     REQUIRE(front.value == 1);
117 |     result.nested_values.pop_front();
118 |     front = result.nested_values.front();
119 |     REQUIRE(front.value == 2);
120 |     result.nested_values.pop_front();
121 |     front = result.nested_values.front();
122 |     REQUIRE(front.value == 3);
123 |     result.nested_values.pop_front();
124 |   }
125 | }


--------------------------------------------------------------------------------
/test/test_deserialize_list_from_array.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize list<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::list<char> values;
 10 |   };
 11 | 
 12 |   std::array<uint8_t, 20> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     auto bytes_written = serialize(s, bytes);
 17 |     REQUIRE(bytes_written == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::list<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize list<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::list<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::array<uint8_t, 20> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     auto bytes_written = serialize(s, bytes);
 38 |     REQUIRE(bytes_written == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::list<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize list<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::list<int> values;
 52 |   };
 53 | 
 54 |   std::array<uint8_t, 20> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     auto bytes_written = serialize(s, bytes);
 59 |     REQUIRE(bytes_written == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::list<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize list<list<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::list<std::list<char>> values;
 73 |   };
 74 | 
 75 |   std::array<uint8_t, 20> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::list<std::list<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize list<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::list<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::list<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::array<uint8_t, 32> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::list<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     auto front = result.nested_values.front();
116 |     REQUIRE(front.value == 1);
117 |     result.nested_values.pop_front();
118 |     front = result.nested_values.front();
119 |     REQUIRE(front.value == 2);
120 |     result.nested_values.pop_front();
121 |     front = result.nested_values.front();
122 |     REQUIRE(front.value == 3);
123 |     result.nested_values.pop_front();
124 |   }
125 | }


--------------------------------------------------------------------------------
/test/test_deserialize_map.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize map<char, int>" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::map<char, int> value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   {
15 |     my_struct s{{{'x', 1}, {'y', 2}, {'z', 3}}};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.size() == 3);
24 |     REQUIRE(result.value.at('x') == 1);
25 |     REQUIRE(result.value.at('y') == 2);
26 |     REQUIRE(result.value.at('z') == 3);
27 |   }
28 | }
29 | 
30 | TEST_CASE("Deserialize unordered_map<string, vector<int>>" *
31 |           test_suite("map")) {
32 |   struct my_struct {
33 |     std::unordered_map<std::string, std::vector<int>> value;
34 |   };
35 | 
36 |   std::vector<uint8_t> bytes;
37 | 
38 |   {
39 |     my_struct s{{{"time", {0, 1, 2, 3, 4}}, {"x", {5, 10, 15}}}};
40 |     serialize(s, bytes);
41 |   }
42 | 
43 |   {
44 |     std::error_code ec;
45 |     auto result = deserialize<my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE(result.value.size() == 2);
48 |     REQUIRE((result.value.at("time") == std::vector<int>{0, 1, 2, 3, 4}));
49 |     REQUIRE((result.value.at("x") == std::vector<int>{5, 10, 15}));
50 |   }
51 | }
52 | 
53 | TEST_CASE("Deserialize unordered_map<string, vector<int>>" *
54 |           test_suite("map")) {
55 |   struct my_struct {
56 |     std::unordered_map<std::string, std::map<int, double>> value;
57 |   };
58 | 
59 |   std::vector<uint8_t> bytes;
60 | 
61 |   {
62 |     my_struct s{{{"time", {{0, 1.1}, {1, 2.2}}}, {"x", {{3, 4.4}, {4, 5.5}}}}};
63 |     serialize(s, bytes);
64 |   }
65 | 
66 |   {
67 |     std::error_code ec;
68 |     auto result = deserialize<my_struct>(bytes, ec);
69 |     REQUIRE((bool)ec == false);
70 |     REQUIRE(result.value.size() == 2);
71 |     REQUIRE(
72 |         (result.value.at("time") == std::map<int, double>{{0, 1.1}, {1, 2.2}}));
73 |     REQUIRE(
74 |         (result.value.at("x") == std::map<int, double>{{3, 4.4}, {4, 5.5}}));
75 |   }
76 | }


--------------------------------------------------------------------------------
/test/test_deserialize_map_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize map<char, int>" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::map<char, int> value;
10 |   };
11 | 
12 |   std::array<uint8_t, 100> bytes;
13 | 
14 |   {
15 |     my_struct s{{{'x', 1}, {'y', 2}, {'z', 3}}};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.size() == 3);
24 |     REQUIRE(result.value.at('x') == 1);
25 |     REQUIRE(result.value.at('y') == 2);
26 |     REQUIRE(result.value.at('z') == 3);
27 |   }
28 | }
29 | 
30 | TEST_CASE("Deserialize unordered_map<string, vector<int>>" *
31 |           test_suite("map")) {
32 |   struct my_struct {
33 |     std::unordered_map<std::string, std::vector<int>> value;
34 |   };
35 | 
36 |   std::array<uint8_t, 100> bytes;
37 | 
38 |   {
39 |     my_struct s{{{"time", {0, 1, 2, 3, 4}}, {"x", {5, 10, 15}}}};
40 |     serialize(s, bytes);
41 |   }
42 | 
43 |   {
44 |     std::error_code ec;
45 |     auto result = deserialize<my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE(result.value.size() == 2);
48 |     REQUIRE((result.value.at("time") == std::vector<int>{0, 1, 2, 3, 4}));
49 |     REQUIRE((result.value.at("x") == std::vector<int>{5, 10, 15}));
50 |   }
51 | }
52 | 
53 | TEST_CASE("Deserialize unordered_map<string, vector<int>>" *
54 |           test_suite("map")) {
55 |   struct my_struct {
56 |     std::unordered_map<std::string, std::map<int, double>> value;
57 |   };
58 | 
59 |   std::array<uint8_t, 100> bytes;
60 | 
61 |   {
62 |     my_struct s{{{"time", {{0, 1.1}, {1, 2.2}}}, {"x", {{3, 4.4}, {4, 5.5}}}}};
63 |     serialize(s, bytes);
64 |   }
65 | 
66 |   {
67 |     std::error_code ec;
68 |     auto result = deserialize<my_struct>(bytes, ec);
69 |     REQUIRE((bool)ec == false);
70 |     REQUIRE(result.value.size() == 2);
71 |     REQUIRE(
72 |         (result.value.at("time") == std::map<int, double>{{0, 1.1}, {1, 2.2}}));
73 |     REQUIRE(
74 |         (result.value.at("x") == std::map<int, double>{{3, 4.4}, {4, 5.5}}));
75 |   }
76 | }


--------------------------------------------------------------------------------
/test/test_deserialize_optional.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize optional<int>" * test_suite("optional")) {
 8 |   struct my_struct {
 9 |     std::optional<int> value;
10 |   };
11 | 
12 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
13 |   {
14 |     std::vector<uint8_t> bytes;
15 |     {
16 |       my_struct s{5};
17 |       serialize<my_struct, 1>(s, bytes); // number of fields in struct specified
18 |       REQUIRE(bytes.size() == 2);
19 |     }
20 |     {
21 |       std::error_code ec;
22 |       auto result = deserialize<my_struct>(
23 |           bytes, ec); // fail, number of fields in struct deduced as 0
24 |       REQUIRE((bool)ec == false);
25 |       REQUIRE(result.value.has_value() == false);
26 |     }
27 |   }
28 | #endif
29 | 
30 |   {
31 |     std::vector<uint8_t> bytes;
32 |     {
33 |       my_struct s{5};
34 |       serialize<my_struct, 1>(s, bytes); // number of fields in struct specified
35 |       REQUIRE(bytes.size() == 2);
36 |     }
37 |     {
38 |       std::error_code ec;
39 |       auto result = deserialize<my_struct, 1>(
40 |           bytes, ec); // number of fields in struct specified
41 |       REQUIRE((bool)ec == false);
42 |       REQUIRE(result.value.has_value() == true);
43 |       REQUIRE(result.value.value() == 5);
44 |     }
45 |   }
46 | 
47 |   {
48 |     std::vector<uint8_t> bytes;
49 |     {
50 |       my_struct s{};
51 |       serialize<my_struct, 1>(s, bytes); // number of fields in struct specified
52 |       REQUIRE(bytes.size() == 1);
53 |     }
54 |     {
55 |       std::error_code ec;
56 |       auto result = deserialize<my_struct, 1>(
57 |           bytes, ec); // number of fields in struct specified
58 |       REQUIRE((bool)ec == false);
59 |       REQUIRE(result.value.has_value() == false);
60 |     }
61 |   }
62 | }
63 | 
64 | TEST_CASE("Deserialize optional sandwiched by regular types" *
65 |           test_suite("optional")) {
66 |   struct my_struct {
67 |     bool before;
68 |     std::optional<int> value;
69 |     float after;
70 |   };
71 | 
72 |   {
73 |     std::vector<uint8_t> bytes;
74 |     {
75 |       my_struct s{true, 5, 3.14f};
76 |       // number of fields in struct needs to be specified
77 |       serialize<my_struct, 3>(s, bytes);
78 |       REQUIRE(bytes.size() == 7);
79 |     }
80 |     {
81 |       // number of fields in struct needs to be specified
82 |       std::error_code ec;
83 |       auto result = deserialize<my_struct, 3>(bytes, ec);
84 |       REQUIRE((bool)ec == false);
85 |       REQUIRE(result.before == true);
86 |       REQUIRE(result.value.has_value() == true);
87 |       REQUIRE(result.value.value() == 5);
88 |       REQUIRE(result.after == 3.14f);
89 |     }
90 |   }
91 | }


--------------------------------------------------------------------------------
/test/test_deserialize_optional_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize optional<int>" * test_suite("optional")) {
 8 |   struct my_struct {
 9 |     std::optional<int> value;
10 |   };
11 | 
12 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
13 |   {
14 |     std::array<uint8_t, 10> bytes;
15 |     {
16 |       my_struct s{5};
17 |       auto bytes_written = serialize<my_struct, 1>(
18 |           s, bytes); // number of fields in struct specified
19 |       REQUIRE(bytes_written == 2);
20 |     }
21 |     {
22 |       std::error_code ec;
23 |       auto result = deserialize<my_struct>(
24 |           bytes, ec); // fail, number of fields in struct deduced as 0
25 |       REQUIRE((bool)ec == false);
26 |       REQUIRE(result.value.has_value() == false);
27 |     }
28 |   }
29 | #endif
30 | 
31 |   {
32 |     std::array<uint8_t, 10> bytes;
33 |     {
34 |       my_struct s{5};
35 |       auto bytes_written = serialize<my_struct, 1>(
36 |           s, bytes); // number of fields in struct specified
37 |       REQUIRE(bytes_written == 2);
38 |     }
39 |     {
40 |       std::error_code ec;
41 |       auto result = deserialize<my_struct, 1>(
42 |           bytes, ec); // number of fields in struct specified
43 |       REQUIRE((bool)ec == false);
44 |       REQUIRE(result.value.has_value() == true);
45 |       REQUIRE(result.value.value() == 5);
46 |     }
47 |   }
48 | 
49 |   {
50 |     std::array<uint8_t, 10> bytes;
51 |     {
52 |       my_struct s{};
53 |       auto bytes_written = serialize<my_struct, 1>(
54 |           s, bytes); // number of fields in struct specified
55 |       REQUIRE(bytes_written == 1);
56 |     }
57 |     {
58 |       std::error_code ec;
59 |       auto result = deserialize<my_struct, 1>(
60 |           bytes, ec); // number of fields in struct specified
61 |       REQUIRE((bool)ec == false);
62 |       REQUIRE(result.value.has_value() == false);
63 |     }
64 |   }
65 | }
66 | 
67 | TEST_CASE("Deserialize optional sandwiched by regular types" *
68 |           test_suite("optional")) {
69 |   struct my_struct {
70 |     bool before;
71 |     std::optional<int> value;
72 |     float after;
73 |   };
74 | 
75 |   {
76 |     std::array<uint8_t, 10> bytes;
77 |     {
78 |       my_struct s{true, 5, 3.14f};
79 |       // number of fields in struct needs to be specified
80 |       auto bytes_written = serialize<my_struct, 3>(s, bytes);
81 |       REQUIRE(bytes_written == 7);
82 |     }
83 |     {
84 |       // number of fields in struct needs to be specified
85 |       std::error_code ec;
86 |       auto result = deserialize<my_struct, 3>(bytes, ec);
87 |       REQUIRE((bool)ec == false);
88 |       REQUIRE(result.before == true);
89 |       REQUIRE(result.value.has_value() == true);
90 |       REQUIRE(result.value.value() == 5);
91 |       REQUIRE(result.after == 3.14f);
92 |     }
93 |   }
94 | }


--------------------------------------------------------------------------------
/test/test_deserialize_pair.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize pair<int, double>" * test_suite("pair")) {
 8 |   struct my_struct {
 9 |     std::pair<int, double> value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   {
15 |     my_struct s{std::make_pair(5, 3.14)};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.first == 5);
24 |     REQUIRE(result.value.second == 3.14);
25 |   }
26 | }
27 | 
28 | TEST_CASE("Deserialize pair<std::vector<int>, std::vector<float>>" *
29 |           test_suite("pair")) {
30 |   struct my_struct {
31 |     std::pair<std::vector<int>, std::vector<float>> value;
32 |   };
33 | 
34 |   std::vector<uint8_t> bytes;
35 | 
36 |   {
37 |     my_struct s{std::make_pair(std::vector<int>{1, 2, 3},
38 |                                std::vector<float>{1.1, 2.2, 3.3})};
39 |     serialize(s, bytes);
40 |   }
41 | 
42 |   {
43 |     std::error_code ec;
44 |     auto result = deserialize<my_struct>(bytes, ec);
45 |     REQUIRE((bool)ec == false);
46 |     REQUIRE((result.value.first == std::vector<int>{1, 2, 3}));
47 |     REQUIRE(result.value.second == std::vector<float>{1.1, 2.2, 3.3});
48 |   }
49 | }


--------------------------------------------------------------------------------
/test/test_deserialize_pair_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize pair<int, double>" * test_suite("pair")) {
 8 |   struct my_struct {
 9 |     std::pair<int, double> value;
10 |   };
11 | 
12 |   std::array<uint8_t, 10> bytes;
13 | 
14 |   {
15 |     my_struct s{std::make_pair(5, 3.14)};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.first == 5);
24 |     REQUIRE(result.value.second == 3.14);
25 |   }
26 | }
27 | 
28 | TEST_CASE("Deserialize pair<std::vector<int>, std::vector<float>>" *
29 |           test_suite("pair")) {
30 |   struct my_struct {
31 |     std::pair<std::vector<int>, std::vector<float>> value;
32 |   };
33 | 
34 |   std::array<uint8_t, 20> bytes;
35 | 
36 |   {
37 |     my_struct s{std::make_pair(std::vector<int>{1, 2, 3},
38 |                                std::vector<float>{1.1, 2.2, 3.3})};
39 |     serialize(s, bytes);
40 |   }
41 | 
42 |   {
43 |     std::error_code ec;
44 |     auto result = deserialize<my_struct>(bytes, ec);
45 |     REQUIRE((bool)ec == false);
46 |     REQUIRE((result.value.first == std::vector<int>{1, 2, 3}));
47 |     REQUIRE(result.value.second == std::vector<float>{1.1, 2.2, 3.3});
48 |   }
49 | }


--------------------------------------------------------------------------------
/test/test_deserialize_set.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize set<int>" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::set<int> value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   {
15 |     my_struct s{{1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 4}};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.size() == 4);
24 |     REQUIRE(result.value.find(1) != result.value.end());
25 |     REQUIRE(result.value.find(2) != result.value.end());
26 |     REQUIRE(result.value.find(3) != result.value.end());
27 |     REQUIRE(result.value.find(4) != result.value.end());
28 |   }
29 | }


--------------------------------------------------------------------------------
/test/test_deserialize_set_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize set<int>" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::set<int> value;
10 |   };
11 | 
12 |   std::array<uint8_t, 10> bytes;
13 | 
14 |   {
15 |     my_struct s{{1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 4}};
16 |     serialize(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value.size() == 4);
24 |     REQUIRE(result.value.find(1) != result.value.end());
25 |     REQUIRE(result.value.find(2) != result.value.end());
26 |     REQUIRE(result.value.find(3) != result.value.end());
27 |     REQUIRE(result.value.find(4) != result.value.end());
28 |   }
29 | }


--------------------------------------------------------------------------------
/test/test_deserialize_string.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Deserialize std::string" * test_suite("string")) {
17 |   struct my_struct {
18 |     std::string value;
19 |   };
20 | 
21 |   std::vector<uint8_t> bytes;
22 | 
23 |   // serialize
24 |   {
25 |     my_struct s{"Hello World!"};
26 |     serialize(s, bytes);
27 |   }
28 | 
29 |   // deserialize
30 |   {
31 |     std::error_code ec;
32 |     auto result = deserialize<my_struct>(bytes, ec);
33 |     REQUIRE((bool)ec == false);
34 |     REQUIRE(result.value == std::string{"Hello World!"});
35 |   }
36 | }
37 | 
38 | TEST_CASE("Deserialize int and std::string" * test_suite("string")) {
39 |   struct my_struct {
40 |     int index;
41 |     std::string value;
42 |   };
43 | 
44 |   std::vector<uint8_t> bytes;
45 | 
46 |   // serialize
47 |   {
48 |     my_struct s{5, "Hello World!"};
49 |     serialize(s, bytes);
50 |   }
51 | 
52 |   // deserialize
53 |   {
54 |     std::error_code ec;
55 |     auto result = deserialize<my_struct>(bytes, ec);
56 |     REQUIRE((bool)ec == false);
57 |     REQUIRE(result.index == 5);
58 |     REQUIRE(result.value == std::string{"Hello World!"});
59 |   }
60 | }


--------------------------------------------------------------------------------
/test/test_deserialize_string_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Deserialize std::string" * test_suite("string")) {
17 |   struct my_struct {
18 |     std::string value;
19 |   };
20 | 
21 |   std::array<uint8_t, 20> bytes;
22 | 
23 |   // serialize
24 |   {
25 |     my_struct s{"Hello World!"};
26 |     serialize(s, bytes);
27 |   }
28 | 
29 |   // deserialize
30 |   {
31 |     std::error_code ec;
32 |     auto result = deserialize<my_struct>(bytes, ec);
33 |     REQUIRE((bool)ec == false);
34 |     REQUIRE(result.value == std::string{"Hello World!"});
35 |   }
36 | }
37 | 
38 | TEST_CASE("Deserialize int and std::string" * test_suite("string")) {
39 |   struct my_struct {
40 |     int index;
41 |     std::string value;
42 |   };
43 | 
44 |   std::array<uint8_t, 20> bytes;
45 | 
46 |   // serialize
47 |   {
48 |     my_struct s{5, "Hello World!"};
49 |     serialize(s, bytes);
50 |   }
51 | 
52 |   // deserialize
53 |   {
54 |     std::error_code ec;
55 |     auto result = deserialize<my_struct>(bytes, ec);
56 |     REQUIRE((bool)ec == false);
57 |     REQUIRE(result.index == 5);
58 |     REQUIRE(result.value == std::string{"Hello World!"});
59 |   }
60 | }


--------------------------------------------------------------------------------
/test/test_deserialize_tuple.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize tuple<int, float, bool>" * test_suite("tuple")) {
 8 |   struct my_struct {
 9 |     std::tuple<int, float, bool, std::string, char> values;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 |   {
14 |     my_struct s{std::make_tuple(5, 3.14, true, "Hello", 'i')};
15 |     serialize(s, bytes);
16 |   }
17 |   {
18 |     std::error_code ec;
19 |     auto result = deserialize<my_struct>(bytes, ec);
20 |     REQUIRE((bool)ec == false);
21 |     REQUIRE(std::get<0>(result.values) == 5);
22 |     REQUIRE(std::get<1>(result.values) == 3.14f);
23 |     REQUIRE(std::get<2>(result.values) == true);
24 |     REQUIRE(std::get<3>(result.values) == std::string{"Hello"});
25 |     REQUIRE(std::get<4>(result.values) == 'i');
26 |   }
27 | }
28 | 
29 | TEST_CASE("Deserialize tuple<std::vector<int>, std::vector<tuple>>" *
30 |           test_suite("tuple")) {
31 |   struct my_struct {
32 |     std::tuple<std::vector<int>, std::vector<std::tuple<int, float>>> values;
33 |   };
34 | 
35 |   std::vector<uint8_t> bytes;
36 |   {
37 |     my_struct s{
38 |         std::make_tuple(std::vector<int>{1, 2, 3},
39 |                         std::vector<std::tuple<int, float>>{
40 |                             std::make_tuple(4, 5.5), std::make_tuple(6, 7.7)})};
41 |     serialize(s, bytes);
42 |   }
43 |   {
44 |     std::error_code ec;
45 |     auto result = deserialize<my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE((std::get<0>(result.values) == std::vector<int>{1, 2, 3}));
48 |     REQUIRE((std::get<1>(result.values) ==
49 |              std::vector<std::tuple<int, float>>{std::make_tuple(4, 5.5),
50 |                                                  std::make_tuple(6, 7.7)}));
51 |   }
52 | }


--------------------------------------------------------------------------------
/test/test_deserialize_tuple_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize tuple<int, float, bool>" * test_suite("tuple")) {
 8 |   struct my_struct {
 9 |     std::tuple<int, float, bool, std::string, char> values;
10 |   };
11 | 
12 |   std::array<uint8_t, 32> bytes;
13 |   {
14 |     my_struct s{std::make_tuple(5, 3.14, true, "Hello", 'i')};
15 |     serialize(s, bytes);
16 |   }
17 |   {
18 |     std::error_code ec;
19 |     auto result = deserialize<my_struct>(bytes, ec);
20 |     REQUIRE((bool)ec == false);
21 |     REQUIRE(std::get<0>(result.values) == 5);
22 |     REQUIRE(std::get<1>(result.values) == 3.14f);
23 |     REQUIRE(std::get<2>(result.values) == true);
24 |     REQUIRE(std::get<3>(result.values) == std::string{"Hello"});
25 |     REQUIRE(std::get<4>(result.values) == 'i');
26 |   }
27 | }
28 | 
29 | TEST_CASE("Deserialize tuple<std::vector<int>, std::vector<tuple>>" *
30 |           test_suite("tuple")) {
31 |   struct my_struct {
32 |     std::tuple<std::vector<int>, std::vector<std::tuple<int, float>>> values;
33 |   };
34 | 
35 |   std::array<uint8_t, 32> bytes;
36 |   {
37 |     my_struct s{
38 |         std::make_tuple(std::vector<int>{1, 2, 3},
39 |                         std::vector<std::tuple<int, float>>{
40 |                             std::make_tuple(4, 5.5), std::make_tuple(6, 7.7)})};
41 |     serialize(s, bytes);
42 |   }
43 |   {
44 |     std::error_code ec;
45 |     auto result = deserialize<my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE((std::get<0>(result.values) == std::vector<int>{1, 2, 3}));
48 |     REQUIRE((std::get<1>(result.values) ==
49 |              std::vector<std::tuple<int, float>>{std::make_tuple(4, 5.5),
50 |                                                  std::make_tuple(6, 7.7)}));
51 |   }
52 | }


--------------------------------------------------------------------------------
/test/test_deserialize_unique_ptr.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
 8 | 
 9 | template <class T> struct Node {
10 |   T data;
11 |   std::unique_ptr<Node<T>> left;
12 |   std::unique_ptr<Node<T>> right;
13 | };
14 | 
15 | template <class T>
16 | auto make_node(T const &value, std::unique_ptr<Node<T>> lhs = nullptr,
17 |                std::unique_ptr<Node<T>> rhs = nullptr) {
18 |   return std::unique_ptr<Node<T>>(
19 |       new Node<T>{value, std::move(lhs), std::move(rhs)});
20 | }
21 | 
22 | TEST_CASE("Serialize unique_ptr<struct>" * test_suite("unique_ptr")) {
23 | 
24 |   std::vector<uint8_t> bytes;
25 | 
26 |   // serialize
27 |   {
28 |     /*
29 |             5
30 |            / \
31 |           3   4
32 |          / \
33 |         1   2
34 |     */
35 | 
36 |     auto const root =
37 |         make_node(5, make_node(3, make_node(1), make_node(2)), make_node(4));
38 | 
39 |     serialize(*root, bytes); // 15 bytes
40 |   }
41 | 
42 |   {
43 |     std::error_code ec;
44 |     auto tree = deserialize<Node<int>>(bytes, ec);
45 |     REQUIRE((bool)ec == false);
46 |     REQUIRE(tree.data == 5);
47 |     auto &left_subtree_0 = *(tree.left);
48 |     REQUIRE(left_subtree_0.data == 3);
49 |     const auto &right_subtree_0 = *(tree.right);
50 |     REQUIRE(right_subtree_0.data == 4);
51 |     REQUIRE(right_subtree_0.left == nullptr);
52 |     REQUIRE(right_subtree_0.right == nullptr);
53 |     const auto &left_subtree_1 = *(left_subtree_0.left);
54 |     REQUIRE(left_subtree_1.data == 1);
55 |     REQUIRE(left_subtree_1.left == nullptr);
56 |     REQUIRE(left_subtree_1.right == nullptr);
57 |     const auto &right_subtree_1 = *(left_subtree_0.right);
58 |     REQUIRE(right_subtree_1.data == 2);
59 |     REQUIRE(right_subtree_1.left == nullptr);
60 |     REQUIRE(right_subtree_1.right == nullptr);
61 |   }
62 | }
63 | 
64 | #endif


--------------------------------------------------------------------------------
/test/test_deserialize_unique_ptr_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
 8 | 
 9 | template <class T> struct Node {
10 |   T data;
11 |   std::unique_ptr<Node<T>> left;
12 |   std::unique_ptr<Node<T>> right;
13 | };
14 | 
15 | template <class T>
16 | auto make_node(T const &value, std::unique_ptr<Node<T>> lhs = nullptr,
17 |                std::unique_ptr<Node<T>> rhs = nullptr) {
18 |   return std::unique_ptr<Node<T>>(
19 |       new Node<T>{value, std::move(lhs), std::move(rhs)});
20 | }
21 | 
22 | TEST_CASE("Serialize unique_ptr<struct>" * test_suite("unique_ptr")) {
23 | 
24 |   std::array<uint8_t, 20> bytes;
25 | 
26 |   // serialize
27 |   {
28 |     /*
29 |             5
30 |            / \
31 |           3   4
32 |          / \
33 |         1   2
34 |     */
35 | 
36 |     auto const root =
37 |         make_node(5, make_node(3, make_node(1), make_node(2)), make_node(4));
38 | 
39 |     serialize(*root, bytes); // 15 bytes
40 |   }
41 | 
42 |   {
43 |     std::error_code ec;
44 |     auto tree = deserialize<Node<int>>(bytes, ec);
45 |     REQUIRE((bool)ec == false);
46 |     REQUIRE(tree.data == 5);
47 |     auto &left_subtree_0 = *(tree.left);
48 |     REQUIRE(left_subtree_0.data == 3);
49 |     const auto &right_subtree_0 = *(tree.right);
50 |     REQUIRE(right_subtree_0.data == 4);
51 |     REQUIRE(right_subtree_0.left == nullptr);
52 |     REQUIRE(right_subtree_0.right == nullptr);
53 |     const auto &left_subtree_1 = *(left_subtree_0.left);
54 |     REQUIRE(left_subtree_1.data == 1);
55 |     REQUIRE(left_subtree_1.left == nullptr);
56 |     REQUIRE(left_subtree_1.right == nullptr);
57 |     const auto &right_subtree_1 = *(left_subtree_0.right);
58 |     REQUIRE(right_subtree_1.data == 2);
59 |     REQUIRE(right_subtree_1.left == nullptr);
60 |     REQUIRE(right_subtree_1.right == nullptr);
61 |   }
62 | }
63 | 
64 | #endif


--------------------------------------------------------------------------------
/test/test_deserialize_ustring.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize std::u16string" * test_suite("string")) {
 8 |   struct my_struct {
 9 |     std::wstring name;
10 |     std::u16string example;
11 |     std::u32string greeting;
12 |   };
13 | 
14 |   std::vector<uint8_t> bytes;
15 | 
16 |   // serialize
17 |   {
18 |     my_struct s{L"緋村 剣心", u"This is a string", U"Hello, 世界"};
19 |     serialize(s, bytes);
20 |   }
21 | 
22 |   // deserialize
23 |   {
24 |     std::error_code ec;
25 |     auto result = deserialize<my_struct>(bytes, ec);
26 |     REQUIRE((bool)ec == false);
27 |     REQUIRE(result.name == L"緋村 剣心");
28 |     REQUIRE(result.example == u"This is a string");
29 |     REQUIRE(result.greeting == U"Hello, 世界");
30 |   }
31 | }


--------------------------------------------------------------------------------
/test/test_deserialize_variant.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize variant" * test_suite("variant")) {
 8 |   struct my_struct {
 9 |     std::variant<int, std::string> value;
10 |   };
11 | 
12 |   {
13 |     std::vector<uint8_t> bytes;
14 |     {
15 |       my_struct s{5};
16 |       serialize(s, bytes);
17 |     }
18 |     {
19 |       std::error_code ec;
20 |       auto result = deserialize<my_struct>(bytes, ec);
21 |       REQUIRE((bool)ec == false);
22 |       REQUIRE(std::get<0>(result.value) == 5);
23 |     }
24 |   }
25 | 
26 |   {
27 |     std::vector<uint8_t> bytes;
28 |     {
29 |       my_struct s{"Hello"};
30 |       serialize(s, bytes);
31 |     }
32 |     {
33 |       std::error_code ec;
34 |       auto result = deserialize<my_struct>(bytes, ec);
35 |       REQUIRE((bool)ec == false);
36 |       REQUIRE(std::get<1>(result.value) == "Hello");
37 |     }
38 |   }
39 | }
40 | 
41 | TEST_CASE("Deserialize map<string, variant>" * test_suite("variant")) {
42 |   struct my_struct {
43 |     std::map<std::string, std::variant<uint16_t, std::string, bool,
44 |                                        std::vector<std::string>>>
45 |         config;
46 |   };
47 | 
48 |   std::vector<uint8_t> bytes;
49 |   {
50 |     my_struct s{{{"keepalive", true},
51 |                  {"port", uint16_t{8080}},
52 |                  {"ip_address", std::string{"192.168.8.1"}},
53 |                  {"subscriptions",
54 |                   std::vector<std::string>{"motor_state", "battery_state"}}}};
55 |     serialize(s, bytes);
56 |   }
57 | 
58 |   {
59 |     std::error_code ec;
60 |     auto result = deserialize<my_struct>(bytes, ec);
61 |     REQUIRE((bool)ec == false);
62 |     REQUIRE(result.config.size() == 4);
63 |     auto &value = result.config.at("keepalive");
64 |     REQUIRE(std::get<2>(value) == true);
65 |     value = result.config.at("port");
66 |     REQUIRE(std::get<0>(value) == 8080);
67 |     value = result.config.at("ip_address");
68 |     REQUIRE(std::get<1>(value) == std::string{"192.168.8.1"});
69 |     value = result.config.at("subscriptions");
70 |     REQUIRE(std::get<3>(value) ==
71 |             std::vector<std::string>{"motor_state", "battery_state"});
72 |   }
73 | }


--------------------------------------------------------------------------------
/test/test_deserialize_variant_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize variant" * test_suite("variant")) {
 8 |   struct my_struct {
 9 |     std::variant<int, std::string> value;
10 |   };
11 | 
12 |   {
13 |     std::array<uint8_t, 20> bytes;
14 |     {
15 |       my_struct s{5};
16 |       serialize(s, bytes);
17 |     }
18 |     {
19 |       std::error_code ec;
20 |       auto result = deserialize<my_struct>(bytes, ec);
21 |       REQUIRE((bool)ec == false);
22 |       REQUIRE(std::get<0>(result.value) == 5);
23 |     }
24 |   }
25 | 
26 |   {
27 |     std::array<uint8_t, 20> bytes;
28 |     {
29 |       my_struct s{"Hello"};
30 |       serialize(s, bytes);
31 |     }
32 |     {
33 |       std::error_code ec;
34 |       auto result = deserialize<my_struct>(bytes, ec);
35 |       REQUIRE((bool)ec == false);
36 |       REQUIRE(std::get<1>(result.value) == "Hello");
37 |     }
38 |   }
39 | }
40 | 
41 | TEST_CASE("Deserialize map<string, variant>" * test_suite("variant")) {
42 |   struct my_struct {
43 |     std::map<std::string, std::variant<uint16_t, std::string, bool,
44 |                                        std::vector<std::string>>>
45 |         config;
46 |   };
47 | 
48 |   std::array<uint8_t, 100> bytes;
49 |   {
50 |     my_struct s{{{"keepalive", true},
51 |                  {"port", uint16_t{8080}},
52 |                  {"ip_address", std::string{"192.168.8.1"}},
53 |                  {"subscriptions",
54 |                   std::vector<std::string>{"motor_state", "battery_state"}}}};
55 |     serialize(s, bytes);
56 |   }
57 | 
58 |   {
59 |     std::error_code ec;
60 |     auto result = deserialize<my_struct>(bytes, ec);
61 |     REQUIRE((bool)ec == false);
62 |     REQUIRE(result.config.size() == 4);
63 |     auto &value = result.config.at("keepalive");
64 |     REQUIRE(std::get<2>(value) == true);
65 |     value = result.config.at("port");
66 |     REQUIRE(std::get<0>(value) == 8080);
67 |     value = result.config.at("ip_address");
68 |     REQUIRE(std::get<1>(value) == std::string{"192.168.8.1"});
69 |     value = result.config.at("subscriptions");
70 |     REQUIRE(std::get<3>(value) ==
71 |             std::vector<std::string>{"motor_state", "battery_state"});
72 |   }
73 | }


--------------------------------------------------------------------------------
/test/test_deserialize_vector.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize vector<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::vector<char> values;
 10 |   };
 11 | 
 12 |   std::vector<uint8_t> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     serialize(s, bytes);
 17 |     REQUIRE(bytes.size() == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::vector<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize vector<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::vector<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::vector<uint8_t> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     serialize(s, bytes);
 38 |     REQUIRE(bytes.size() == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::vector<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize vector<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::vector<int> values;
 52 |   };
 53 | 
 54 |   std::vector<uint8_t> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     serialize(s, bytes);
 59 |     REQUIRE(bytes.size() == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::vector<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize vector<vector<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::vector<std::vector<char>> values;
 73 |   };
 74 | 
 75 |   std::vector<uint8_t> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::vector<std::vector<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize vector<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::vector<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::vector<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::vector<uint8_t> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::vector<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     REQUIRE(result.nested_values[0].value == 1);
116 |     REQUIRE(result.nested_values[1].value == 2);
117 |     REQUIRE(result.nested_values[2].value == 3);
118 |   }
119 | }


--------------------------------------------------------------------------------
/test/test_deserialize_vector_from_array.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Deserialize vector<char>" * test_suite("vector")) {
  8 |   struct my_struct {
  9 |     std::vector<char> values;
 10 |   };
 11 | 
 12 |   std::array<uint8_t, 20> bytes;
 13 | 
 14 |   {
 15 |     my_struct s{{'x', 'y', 'z'}};
 16 |     auto bytes_written = serialize(s, bytes);
 17 |     REQUIRE(bytes_written == 4);
 18 |   }
 19 | 
 20 |   {
 21 |     std::error_code ec;
 22 |     auto result = deserialize<my_struct>(bytes, ec);
 23 |     REQUIRE((bool)ec == false);
 24 |     REQUIRE((result.values == std::vector<char>{'x', 'y', 'z'}));
 25 |   }
 26 | }
 27 | 
 28 | TEST_CASE("Deserialize vector<size_t>" * test_suite("vector")) {
 29 |   struct my_struct {
 30 |     std::vector<uint64_t> values;
 31 |   };
 32 | 
 33 |   std::array<uint8_t, 20> bytes;
 34 | 
 35 |   {
 36 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 37 |     auto bytes_written = serialize(s, bytes);
 38 |     REQUIRE(bytes_written == 7);
 39 |   }
 40 | 
 41 |   {
 42 |     std::error_code ec;
 43 |     auto result = deserialize<my_struct>(bytes, ec);
 44 |     REQUIRE((bool)ec == false);
 45 |     REQUIRE((result.values == std::vector<uint64_t>{1, 2, 3, 4, 5, 6}));
 46 |   }
 47 | }
 48 | 
 49 | TEST_CASE("Deserialize vector<int>" * test_suite("vector")) {
 50 |   struct my_struct {
 51 |     std::vector<int> values;
 52 |   };
 53 | 
 54 |   std::array<uint8_t, 20> bytes;
 55 | 
 56 |   {
 57 |     my_struct s{{1, 2, 3, 4, 5, 6}};
 58 |     auto bytes_written = serialize(s, bytes);
 59 |     REQUIRE(bytes_written == 7);
 60 |   }
 61 | 
 62 |   {
 63 |     std::error_code ec;
 64 |     auto result = deserialize<my_struct>(bytes, ec);
 65 |     REQUIRE((bool)ec == false);
 66 |     REQUIRE((result.values == std::vector<int>{1, 2, 3, 4, 5, 6}));
 67 |   }
 68 | }
 69 | 
 70 | TEST_CASE("Deserialize vector<vector<char>>" * test_suite("vector")) {
 71 |   struct my_struct {
 72 |     std::vector<std::vector<char>> values;
 73 |   };
 74 | 
 75 |   std::array<uint8_t, 20> bytes;
 76 | 
 77 |   {
 78 |     my_struct s{{{'a', 'b', 'c'}, {'d', 'e', 'f'}}};
 79 |     serialize(s, bytes);
 80 |   }
 81 | 
 82 |   {
 83 |     std::error_code ec;
 84 |     auto result = deserialize<my_struct>(bytes, ec);
 85 |     REQUIRE((bool)ec == false);
 86 |     REQUIRE((result.values ==
 87 |              std::vector<std::vector<char>>{{'a', 'b', 'c'}, {'d', 'e', 'f'}}));
 88 |   }
 89 | }
 90 | 
 91 | TEST_CASE("Deserialize vector<nested_struct>" * test_suite("vector")) {
 92 |   struct my_struct {
 93 |     std::vector<double> values;
 94 |     struct nested_t {
 95 |       int value;
 96 |     };
 97 |     std::vector<nested_t> nested_values;
 98 |   };
 99 | 
100 |   std::array<uint8_t, 32> bytes;
101 | 
102 |   {
103 |     my_struct s{{1.23, 4.56, 7.89},
104 |                 {my_struct::nested_t{1}, my_struct::nested_t{2},
105 |                  my_struct::nested_t{3}}};
106 |     serialize(s, bytes);
107 |   }
108 | 
109 |   {
110 |     std::error_code ec;
111 |     auto result = deserialize<my_struct>(bytes, ec);
112 |     REQUIRE((bool)ec == false);
113 |     REQUIRE((result.values == std::vector<double>{1.23, 4.56, 7.89}));
114 |     REQUIRE(result.nested_values.size() == 3);
115 |     REQUIRE(result.nested_values[0].value == 1);
116 |     REQUIRE(result.nested_values[1].value == 2);
117 |     REQUIRE(result.nested_values[2].value == 3);
118 |   }
119 | }


--------------------------------------------------------------------------------
/test/test_deserialize_with_crc32.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int with crc32" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{5};
17 |     serialize<options::with_checksum>(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     std::error_code ec;
23 |     auto result = deserialize<options::with_checksum, my_struct>(bytes, ec);
24 |     REQUIRE((bool)ec == false);
25 |     REQUIRE(result.value == 5);
26 |   }
27 | }
28 | 
29 | TEST_CASE("Deserialize int with crc32 (error)" * test_suite("crc32")) {
30 |   struct my_struct {
31 |     int value;
32 |   };
33 | 
34 |   std::vector<uint8_t> bytes;
35 | 
36 |   // serialize
37 |   {
38 |     my_struct s{5};
39 |     serialize<options::with_checksum>(s, bytes);
40 |   }
41 | 
42 |   // deserialize
43 |   {
44 |     std::error_code ec;
45 |     bytes.pop_back(); // remove 1 byte
46 |     deserialize<options::with_checksum, my_struct>(bytes, ec);
47 |     REQUIRE((bool)ec == true);
48 |     REQUIRE(ec.value() == static_cast<int>(std::errc::bad_message));
49 |   }
50 | }


--------------------------------------------------------------------------------
/test/test_deserialize_with_crc32_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int with crc32" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::array<uint8_t, 5> bytes = {0};
13 | 
14 |   // serialize
15 |   {
16 |     my_struct s{5};
17 |     serialize<options::with_checksum>(s, bytes);
18 |   }
19 | 
20 |   // deserialize
21 |   {
22 |     std::error_code ec;
23 |     auto result = deserialize<options::with_checksum, my_struct>(bytes, ec);
24 |     REQUIRE((bool)ec == false);
25 |     REQUIRE(result.value == 5);
26 |   }
27 | }
28 | 
29 | TEST_CASE("Deserialize int with crc32 (error)" * test_suite("crc32")) {
30 |   struct my_struct {
31 |     int value;
32 |   };
33 | 
34 |   std::array<uint8_t, 20> bytes = {0};
35 |   std::size_t bytes_written = 0;
36 | 
37 |   // serialize
38 |   {
39 |     my_struct s{5};
40 |     bytes_written = serialize<options::with_checksum>(s, bytes);
41 |   }
42 | 
43 |   // deserialize
44 |   {
45 |     std::error_code ec;
46 |     bytes[bytes_written - 1] = 0x00; // clear 1 byte
47 |     deserialize<options::with_checksum, my_struct>(bytes, ec);
48 |     REQUIRE((bool)ec == true);
49 |     REQUIRE(ec.value() == static_cast<int>(std::errc::bad_message));
50 |   }
51 | }


--------------------------------------------------------------------------------
/test/test_deserialize_with_version.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int into struct { int }" * test_suite("version")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::vector<uint8_t> bytes;
13 | 
14 |   {
15 |     my_struct s{5};
16 |     serialize<options::with_version>(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<options::with_version, my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value == 5);
24 |   }
25 | }
26 | 
27 | TEST_CASE("Deserialize vector<int> into struct { vector<int> }" *
28 |           test_suite("version")) {
29 | 
30 |   std::vector<uint8_t> bytes;
31 | 
32 |   {
33 |     struct my_struct {
34 |       std::vector<int> value;
35 |     };
36 |     my_struct s{{1, 2, 3, 4, 5}};
37 |     serialize<options::with_version>(s, bytes);
38 |   }
39 | 
40 |   {
41 |     struct my_struct {
42 |       std::vector<int> value;
43 |     };
44 |     std::error_code ec;
45 |     auto result = deserialize<options::with_version, my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE((result.value == std::vector<int>{1, 2, 3, 4, 5}));
48 |   }
49 | }


--------------------------------------------------------------------------------
/test/test_deserialize_with_version_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Deserialize int into struct { int }" * test_suite("version")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   std::array<uint8_t, 20> bytes;
13 | 
14 |   {
15 |     my_struct s{5};
16 |     serialize<options::with_version>(s, bytes);
17 |   }
18 | 
19 |   {
20 |     std::error_code ec;
21 |     auto result = deserialize<options::with_version, my_struct>(bytes, ec);
22 |     REQUIRE((bool)ec == false);
23 |     REQUIRE(result.value == 5);
24 |   }
25 | }
26 | 
27 | TEST_CASE("Deserialize vector<int> into struct { vector<int> }" *
28 |           test_suite("version")) {
29 | 
30 |   std::array<uint8_t, 20> bytes;
31 | 
32 |   {
33 |     struct my_struct {
34 |       std::vector<int> value;
35 |     };
36 |     my_struct s{{1, 2, 3, 4, 5}};
37 |     serialize<options::with_version>(s, bytes);
38 |   }
39 | 
40 |   {
41 |     struct my_struct {
42 |       std::vector<int> value;
43 |     };
44 |     std::error_code ec;
45 |     auto result = deserialize<options::with_version, my_struct>(bytes, ec);
46 |     REQUIRE((bool)ec == false);
47 |     REQUIRE((result.value == std::vector<int>{1, 2, 3, 4, 5}));
48 |   }
49 | }


--------------------------------------------------------------------------------
/test/test_force_alignment.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | constexpr auto OPTIONS = options::fixed_length_encoding | options::force_aligned_access;
 8 | 
 9 | TEST_CASE("Complex structure with non-aligned fields") {
10 | 
11 |   struct Complex {
12 |     uint8_t byte1{0};      // 1 byte
13 |     uint32_t field1{0};    // 4 bytes, starts at offset 1
14 |     uint8_t byte2{0};      // 1 byte, starts at offset 5
15 |     uint64_t field2{0};    // 8 bytes, starts at offset 6
16 |     uint32_t field3{0};    // 4 bytes, starts at offset 14
17 |     uint8_t byte3{0};      // 1 byte, starts at offset 18
18 |   };
19 | 
20 |   Complex data{0x01, 0x12345678, 0x02, 0x1234567890ABCDEF, 0xDEADBEEF, 0x03};
21 | 
22 |   std::vector<uint8_t> bytes;
23 |   alpaca::serialize<OPTIONS>(data, bytes);
24 | 
25 |   std::error_code err;
26 |   auto reconstructed = alpaca::deserialize<OPTIONS, Complex>(bytes, err);
27 | 
28 |   REQUIRE(!err);
29 | 
30 |   REQUIRE(reconstructed.byte1 == data.byte1);
31 |   REQUIRE(reconstructed.field1 == data.field1);
32 |   REQUIRE(reconstructed.byte2 == data.byte2);
33 |   REQUIRE(reconstructed.field2 == data.field2);
34 |   REQUIRE(reconstructed.field3 == data.field3);
35 |   REQUIRE(reconstructed.byte3 == data.byte3);
36 | }
37 | 
38 | TEST_CASE("Nested structures with non-aligned fields") {
39 | 
40 |   struct Inner {
41 |     uint8_t byte1{0};
42 |     uint64_t field1{0};
43 |   };
44 | 
45 |   struct Outer {
46 |     uint8_t byte2{0};
47 |     uint32_t field2{0};
48 |     Inner inner;
49 |     uint8_t byte3{0};
50 |     uint64_t field3{0};
51 |   };
52 | 
53 |   Outer data{0x04, 0x56789ABC, {0x05, 0x1234567890ABCDEF}, 0x06, 0xFEDCBA9876543210};
54 | 
55 |   std::vector<uint8_t> bytes;
56 |   alpaca::serialize<OPTIONS>(data, bytes);
57 | 
58 |   std::error_code err;
59 |   auto reconstructed = alpaca::deserialize<OPTIONS, Outer>(bytes, err);
60 | 
61 |   REQUIRE(!err);
62 | 
63 |   REQUIRE(reconstructed.byte2 == data.byte2);
64 |   REQUIRE(reconstructed.field2 == data.field2);
65 |   REQUIRE(reconstructed.inner.byte1 == data.inner.byte1);
66 |   REQUIRE(reconstructed.inner.field1 == data.inner.field1);
67 |   REQUIRE(reconstructed.byte3 == data.byte3);
68 |   REQUIRE(reconstructed.field3 == data.field3);
69 | }
70 | 


--------------------------------------------------------------------------------
/test/test_forwards_compatibility.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Forwards Compatibility (new field added in struct)" *
 8 |           test_suite("backwards_compatibility")) {
 9 | 
10 |   std::vector<uint8_t> bytes;
11 |   {
12 |     // client side is using an old structure
13 |     struct my_struct {
14 |       int old_field_1;
15 |       float old_field_2;
16 |     };
17 | 
18 |     my_struct s{5, 3.14f};
19 |     serialize(s, bytes);
20 |   }
21 | 
22 |   {
23 |     // server side is updated to use a new structure
24 |     struct my_struct {
25 |       int old_field_1;
26 |       float old_field_2;
27 |       std::string new_field_1;
28 |     };
29 |     std::error_code ec;
30 |     auto s = deserialize<my_struct>(bytes, ec);
31 |     REQUIRE((bool)ec == false);
32 |     REQUIRE(s.old_field_1 == 5);
33 |     REQUIRE(s.old_field_2 == 3.14f);
34 |     REQUIRE(s.new_field_1.empty()); // default initialized
35 |   }
36 | 
37 | #ifndef __APPLE__
38 |   {
39 |     // server side is updated to use a new structure
40 |     struct my_struct {
41 |       int old_field_1;
42 |       float old_field_2;
43 |       std::string new_field_1;
44 |       std::vector<bool> new_field_2;
45 |     };
46 |     std::error_code ec;
47 |     auto s = deserialize<my_struct>(bytes, ec);
48 |     REQUIRE((bool)ec == false);
49 |     REQUIRE(s.old_field_1 == 5);
50 |     REQUIRE(s.old_field_2 == 3.14f);
51 |     REQUIRE(s.new_field_1.empty());     // default initialized
52 |     REQUIRE(s.new_field_2.size() == 0); // default initialized
53 |   }
54 | 
55 |   {
56 |     // server side is updated to use a new structure
57 |     struct my_struct {
58 |       int old_field_1;
59 |       float old_field_2;
60 |       std::string new_field_1;
61 |       std::vector<bool> new_field_2;
62 |       int new_field_3;
63 |     };
64 |     std::error_code ec;
65 |     auto s = deserialize<my_struct>(bytes, ec);
66 |     REQUIRE((bool)ec == false);
67 |     REQUIRE(s.old_field_1 == 5);
68 |     REQUIRE(s.old_field_2 == 3.14f);
69 |     REQUIRE(s.new_field_1.empty());     // default initialized
70 |     REQUIRE(s.new_field_2.size() == 0); // default initialized
71 |     REQUIRE(s.new_field_3 == 0);        // default initialized
72 |   }
73 | #endif
74 | }


--------------------------------------------------------------------------------
/test/test_forwards_compatibility_from_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Forwards Compatibility (new field added in struct)" *
 8 |           test_suite("forward_compatibility")) {
 9 | 
10 |   std::array<uint8_t, 32> bytes = {0};
11 |   {
12 |     // client side is using an old structure
13 |     struct my_struct {
14 |       int old_field_1;
15 |       float old_field_2;
16 |     };
17 | 
18 |     my_struct s{5, 3.14f};
19 |     serialize(s, bytes);
20 |   }
21 | 
22 |   {
23 |     // server side is updated to use a new structure
24 |     struct my_struct {
25 |       int old_field_1;
26 |       float old_field_2;
27 |       std::string new_field_1;
28 |     };
29 |     std::error_code ec;
30 |     auto s = deserialize<my_struct>(bytes, ec);
31 |     REQUIRE((bool)ec == false);
32 |     REQUIRE(s.old_field_1 == 5);
33 |     REQUIRE(s.old_field_2 == 3.14f);
34 |     REQUIRE(s.new_field_1.empty()); // default initialized
35 |   }
36 | 
37 | #ifndef __APPLE__
38 |   {
39 |     // server side is updated to use a new structure
40 |     struct my_struct {
41 |       int old_field_1;
42 |       float old_field_2;
43 |       std::string new_field_1;
44 |       std::vector<bool> new_field_2;
45 |     };
46 |     std::error_code ec;
47 |     auto s = deserialize<my_struct>(bytes, ec);
48 |     REQUIRE((bool)ec == false);
49 |     REQUIRE(s.old_field_1 == 5);
50 |     REQUIRE(s.old_field_2 == 3.14f);
51 |     REQUIRE(s.new_field_1.empty());     // default initialized
52 |     REQUIRE(s.new_field_2.size() == 0); // default initialized
53 |   }
54 | 
55 |   {
56 |     // server side is updated to use a new structure
57 |     struct my_struct {
58 |       int old_field_1;
59 |       float old_field_2;
60 |       std::string new_field_1;
61 |       std::vector<bool> new_field_2;
62 |       int new_field_3;
63 |     };
64 |     std::error_code ec;
65 |     auto s = deserialize<my_struct>(bytes, ec);
66 |     REQUIRE((bool)ec == false);
67 |     REQUIRE(s.old_field_1 == 5);
68 |     REQUIRE(s.old_field_2 == 3.14f);
69 |     REQUIRE(s.new_field_1.empty());     // default initialized
70 |     REQUIRE(s.new_field_2.size() == 0); // default initialized
71 |     REQUIRE(s.new_field_3 == 0);        // default initialized
72 |   }
73 | #endif
74 | }


--------------------------------------------------------------------------------
/test/test_serialize_big_endian.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Serialize uint8_t big endian" * test_suite("signed_integer")) {
  8 |   struct my_struct {
  9 |     uint8_t value;
 10 |   };
 11 | 
 12 |   std::vector<uint8_t> bytes;
 13 | 
 14 |   // serialize
 15 |   {
 16 |     my_struct s{5};
 17 |     serialize<options::big_endian>(s, bytes);
 18 |     REQUIRE(bytes.size() == 1);
 19 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x05));
 20 |   }
 21 | }
 22 | 
 23 | TEST_CASE("Serialize uint16_t big endian" * test_suite("signed_integer")) {
 24 |   struct my_struct {
 25 |     uint16_t value;
 26 |   };
 27 | 
 28 |   // serialize
 29 |   {
 30 |     my_struct s{5};
 31 |     std::vector<uint8_t> bytes;
 32 |     serialize<options::big_endian>(s, bytes);
 33 |     REQUIRE(bytes.size() == 2);
 34 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
 35 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x05));
 36 |   }
 37 | 
 38 |   // serialize
 39 |   {
 40 |     my_struct s{12345};
 41 |     std::vector<uint8_t> bytes;
 42 |     serialize<options::big_endian>(s, bytes);
 43 |     REQUIRE(bytes.size() == 2);
 44 |     REQUIRE(bytes.size() == 2);
 45 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x30));
 46 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x39));
 47 |   }
 48 | }
 49 | 
 50 | TEST_CASE("Serialize positive int8_t big endian" *
 51 |           test_suite("signed_integer")) {
 52 |   struct my_struct {
 53 |     int8_t value;
 54 |   };
 55 | 
 56 |   std::vector<uint8_t> bytes;
 57 | 
 58 |   // serialize
 59 |   {
 60 |     my_struct s{5};
 61 |     serialize<options::big_endian>(s, bytes);
 62 |     REQUIRE(bytes.size() == 1);
 63 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x05));
 64 |   }
 65 | }
 66 | 
 67 | TEST_CASE("Serialize positive int16_t big endian" *
 68 |           test_suite("signed_integer")) {
 69 |   struct my_struct {
 70 |     int16_t value;
 71 |   };
 72 | 
 73 |   // serialize
 74 |   {
 75 |     my_struct s{5};
 76 |     std::vector<uint8_t> bytes;
 77 |     serialize<options::big_endian>(s, bytes);
 78 |     // fixed width encoding
 79 |     REQUIRE(bytes.size() == 2);
 80 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
 81 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x05));
 82 |   }
 83 | 
 84 |   // serialize
 85 |   {
 86 |     my_struct s{12345};
 87 |     std::vector<uint8_t> bytes;
 88 |     serialize<options::big_endian>(s, bytes);
 89 |     REQUIRE(bytes.size() == 2);
 90 |     // fixed width encoding
 91 |     REQUIRE(bytes.size() == 2);
 92 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x30));
 93 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x39));
 94 |   }
 95 | }
 96 | 
 97 | TEST_CASE("Serialize uint32_t big endian" * test_suite("signed_integer")) {
 98 |   struct my_struct {
 99 |     uint32_t value;
100 |   };
101 | 
102 |   std::vector<uint8_t> bytes;
103 | 
104 |   // serialize
105 |   {
106 |     my_struct s{654321};
107 |     serialize<options::big_endian | options::fixed_length_encoding>(s, bytes);
108 |     REQUIRE(bytes.size() == 4);
109 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
110 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x09));
111 |     REQUIRE(bytes[2] == static_cast<uint8_t>(0xFB));
112 |     REQUIRE(bytes[3] == static_cast<uint8_t>(0xF1));
113 |   }
114 | }


--------------------------------------------------------------------------------
/test/test_serialize_big_endian_into_array.cpp:
--------------------------------------------------------------------------------
  1 | #include <alpaca/alpaca.h>
  2 | #include <doctest.hpp>
  3 | using namespace alpaca;
  4 | 
  5 | using doctest::test_suite;
  6 | 
  7 | TEST_CASE("Serialize uint8_t big endian" * test_suite("signed_integer")) {
  8 |   struct my_struct {
  9 |     uint8_t value;
 10 |   };
 11 | 
 12 |   std::vector<uint8_t> bytes;
 13 | 
 14 |   // serialize
 15 |   {
 16 |     my_struct s{5};
 17 |     std::array<uint8_t, 100> bytes;
 18 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 19 |     REQUIRE(bytes_written == 1);
 20 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x05));
 21 |   }
 22 | }
 23 | 
 24 | TEST_CASE("Serialize uint16_t big endian" * test_suite("signed_integer")) {
 25 |   struct my_struct {
 26 |     uint16_t value;
 27 |   };
 28 | 
 29 |   std::vector<uint8_t> bytes;
 30 | 
 31 |   // serialize
 32 |   {
 33 |     my_struct s{5};
 34 |     std::array<uint8_t, 100> bytes;
 35 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 36 |     // fixed width encoding
 37 |     REQUIRE(bytes_written == 2);
 38 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
 39 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x05));
 40 |   }
 41 | 
 42 |   // serialize
 43 |   {
 44 |     my_struct s{12345};
 45 |     std::array<uint8_t, 100> bytes;
 46 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 47 |     REQUIRE(bytes_written == 2);
 48 |     REQUIRE(bytes_written == 2);
 49 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x30));
 50 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x39));
 51 |   }
 52 | }
 53 | 
 54 | TEST_CASE("Serialize positive int8_t big endian" *
 55 |           test_suite("signed_integer")) {
 56 |   struct my_struct {
 57 |     int8_t value;
 58 |   };
 59 | 
 60 |   std::vector<uint8_t> bytes;
 61 | 
 62 |   // serialize
 63 |   {
 64 |     my_struct s{5};
 65 |     std::array<uint8_t, 100> bytes;
 66 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 67 |     REQUIRE(bytes_written == 1);
 68 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x05));
 69 |   }
 70 | }
 71 | 
 72 | TEST_CASE("Serialize positive int16_t big endian" *
 73 |           test_suite("signed_integer")) {
 74 |   struct my_struct {
 75 |     int16_t value;
 76 |   };
 77 | 
 78 |   std::vector<uint8_t> bytes;
 79 | 
 80 |   // serialize
 81 |   {
 82 |     my_struct s{5};
 83 |     std::array<uint8_t, 100> bytes;
 84 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 85 |     // fixed width encoding
 86 |     REQUIRE(bytes_written == 2);
 87 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
 88 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x05));
 89 |   }
 90 | 
 91 |   // serialize
 92 |   {
 93 |     my_struct s{12345};
 94 |     std::array<uint8_t, 100> bytes;
 95 |     auto bytes_written = serialize<options::big_endian>(s, bytes);
 96 |     REQUIRE(bytes_written == 2);
 97 |     // fixed width encoding
 98 |     REQUIRE(bytes_written == 2);
 99 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x30));
100 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x39));
101 |   }
102 | }
103 | 
104 | TEST_CASE("Serialize uint32_t big endian" * test_suite("signed_integer")) {
105 |   struct my_struct {
106 |     uint32_t value;
107 |   };
108 | 
109 |   std::vector<uint8_t> bytes;
110 | 
111 |   // serialize
112 |   {
113 |     my_struct s{654321};
114 |     std::array<uint8_t, 100> bytes;
115 |     auto bytes_written =
116 |         serialize<options::big_endian | options::fixed_length_encoding>(s,
117 |                                                                         bytes);
118 |     REQUIRE(bytes_written == 4);
119 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
120 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x09));
121 |     REQUIRE(bytes[2] == static_cast<uint8_t>(0xFB));
122 |     REQUIRE(bytes[3] == static_cast<uint8_t>(0xF1));
123 |   }
124 | }


--------------------------------------------------------------------------------
/test/test_serialize_bool.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize bool (true)" * test_suite("bool")) {
 8 |   struct my_struct {
 9 |     bool value;
10 |   };
11 | 
12 |   my_struct s{true};
13 |   std::vector<uint8_t> bytes;
14 |   serialize(s, bytes);
15 |   REQUIRE(bytes.size() == 1);
16 |   REQUIRE(bytes[0] == static_cast<uint8_t>(true));
17 | }
18 | 
19 | TEST_CASE("Serialize bool (false)" * test_suite("bool")) {
20 |   struct my_struct {
21 |     bool value;
22 |   };
23 | 
24 |   my_struct s{false};
25 |   std::vector<uint8_t> bytes;
26 |   serialize(s, bytes);
27 |   REQUIRE(bytes.size() == 1);
28 |   REQUIRE(bytes[0] == static_cast<uint8_t>(false));
29 | }


--------------------------------------------------------------------------------
/test/test_serialize_bool_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize bool (true) into array" * test_suite("bool")) {
 8 |   struct my_struct {
 9 |     bool value;
10 |   };
11 | 
12 |   my_struct s{true};
13 |   std::array<uint8_t, 5> bytes;
14 |   auto bytes_written = serialize(s, bytes);
15 |   REQUIRE(bytes_written == 1);
16 |   REQUIRE(bytes[0] == static_cast<uint8_t>(true));
17 | }
18 | 
19 | TEST_CASE("Serialize bool (false) into array" * test_suite("bool")) {
20 |   struct my_struct {
21 |     bool value;
22 |   };
23 | 
24 |   my_struct s{false};
25 |   std::array<uint8_t, 5> bytes;
26 |   auto bytes_written = serialize(s, bytes);
27 |   REQUIRE(bytes_written == 1);
28 |   REQUIRE(bytes[0] == static_cast<uint8_t>(false));
29 | }


--------------------------------------------------------------------------------
/test/test_serialize_chrono_duration.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize chrono duration" * test_suite("chrono_duration")) {
 8 |   struct my_struct {
 9 |     std::chrono::milliseconds period;
10 |   };
11 | 
12 |   my_struct s{std::chrono::milliseconds{500}};
13 | 
14 |   std::vector<uint8_t> bytes;
15 |   auto bytes_written = serialize(s, bytes);
16 | 
17 |   REQUIRE(bytes_written == 3);
18 |   REQUIRE(bytes[0] == static_cast<uint8_t>(0x74));
19 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xf4));
20 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0x03));
21 | }


--------------------------------------------------------------------------------
/test/test_serialize_chrono_duration_to_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize chrono duration to array" *
 8 |           test_suite("chrono_duration")) {
 9 |   struct my_struct {
10 |     std::chrono::milliseconds period;
11 |   };
12 | 
13 |   my_struct s{std::chrono::milliseconds{500}};
14 | 
15 |   std::array<uint8_t, 5> bytes;
16 |   auto bytes_written = serialize(s, bytes);
17 | 
18 |   REQUIRE(bytes_written == 3);
19 |   REQUIRE(bytes[0] == static_cast<uint8_t>(0x74));
20 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xf4));
21 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0x03));
22 | }


--------------------------------------------------------------------------------
/test/test_serialize_enum_class.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize enum class" * test_suite("enum_class")) {
 8 |   struct my_struct {
 9 |     enum class color { red, blue, green };
10 |     color value;
11 |   };
12 | 
13 |   my_struct s{my_struct::color::blue};
14 |   std::vector<uint8_t> bytes;
15 |   serialize(s, bytes);
16 |   REQUIRE(bytes.size() == 1);
17 |   REQUIRE(bytes[0] == static_cast<uint8_t>(1));
18 | }


--------------------------------------------------------------------------------
/test/test_serialize_enum_class_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize enum class into array" * test_suite("enum_class")) {
 8 |   struct my_struct {
 9 |     enum class color { red, blue, green };
10 |     color value;
11 |   };
12 | 
13 |   my_struct s{my_struct::color::blue};
14 |   std::array<uint8_t, 1> bytes;
15 |   auto bytes_written = serialize(s, bytes);
16 |   REQUIRE(bytes_written == 1);
17 |   REQUIRE(bytes[0] == static_cast<uint8_t>(1));
18 | }


--------------------------------------------------------------------------------
/test/test_serialize_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize float" * test_suite("float")) {
17 |   struct my_struct {
18 |     float value;
19 |   };
20 | 
21 |   my_struct s{3.14f};
22 |   std::vector<uint8_t> bytes;
23 |   serialize(s, bytes);
24 |   REQUIRE(bytes.size() == 4);
25 | 
26 |   CONSTRUCT_EXPECTED_VALUE(float, s.value);
27 |   for (std::size_t i = 0; i < bytes.size(); ++i) {
28 |     REQUIRE(bytes[i] == expected[i]);
29 |   }
30 | }
31 | 
32 | TEST_CASE("Serialize double" * test_suite("float")) {
33 |   struct my_struct {
34 |     double value;
35 |   };
36 | 
37 |   my_struct s{2.71828};
38 |   std::vector<uint8_t> bytes;
39 |   serialize(s, bytes);
40 |   REQUIRE(bytes.size() == 8);
41 | 
42 |   CONSTRUCT_EXPECTED_VALUE(double, s.value);
43 |   for (std::size_t i = 0; i < bytes.size(); ++i) {
44 |     REQUIRE(bytes[i] == expected[i]);
45 |   }
46 | }


--------------------------------------------------------------------------------
/test/test_serialize_float_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize float into array" * test_suite("float")) {
17 |   struct my_struct {
18 |     float value;
19 |   };
20 | 
21 |   my_struct s{3.14f};
22 |   std::array<uint8_t, 10> bytes;
23 |   auto bytes_written = serialize(s, bytes);
24 |   REQUIRE(bytes_written == 4);
25 | 
26 |   CONSTRUCT_EXPECTED_VALUE(float, s.value);
27 |   for (std::size_t i = 0; i < bytes_written; ++i) {
28 |     REQUIRE(bytes[i] == expected[i]);
29 |   }
30 | }
31 | 
32 | TEST_CASE("Serialize double into array" * test_suite("float")) {
33 |   struct my_struct {
34 |     double value;
35 |   };
36 | 
37 |   my_struct s{2.71828};
38 |   std::array<uint8_t, 10> bytes;
39 |   auto bytes_written = serialize(s, bytes);
40 |   REQUIRE(bytes_written == 8);
41 | 
42 |   CONSTRUCT_EXPECTED_VALUE(double, s.value);
43 |   for (std::size_t i = 0; i < bytes_written; ++i) {
44 |     REQUIRE(bytes[i] == expected[i]);
45 |   }
46 | }


--------------------------------------------------------------------------------
/test/test_serialize_int_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize int8_t into std::array" * test_suite("signed_integer")) {
 8 |   struct my_struct {
 9 |     int8_t value;
10 |   };
11 | 
12 |   my_struct s{5};
13 |   std::array<uint8_t, 1> bytes;
14 |   serialize(s, bytes);
15 |   REQUIRE(bytes.size() == 1);
16 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
17 | }
18 | 
19 | TEST_CASE("Serialize int16_t into std::array" * test_suite("signed_integer")) {
20 |   struct my_struct {
21 |     int16_t value;
22 |   };
23 | 
24 |   {
25 |     my_struct s{5};
26 |     std::array<uint8_t, 2> bytes;
27 |     serialize(s, bytes);
28 |     REQUIRE(bytes.size() == 2);
29 | 
30 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x05));
31 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x00));
32 |   }
33 | 
34 |   {
35 |     my_struct s{5};
36 |     std::array<uint8_t, 2> bytes;
37 |     serialize<options::big_endian>(s, bytes);
38 |     REQUIRE(bytes.size() == 2);
39 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x00));
40 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x05));
41 |   }
42 | 
43 |   {
44 |     my_struct s{12345};
45 |     std::array<uint8_t, 2> bytes;
46 |     serialize(s, bytes);
47 |     REQUIRE(bytes.size() == 2);
48 | 
49 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x39));
50 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x30));
51 |   }
52 | 
53 |   {
54 |     my_struct s{12345};
55 |     std::array<uint8_t, 2> bytes;
56 |     serialize<options::big_endian>(s, bytes);
57 |     REQUIRE(bytes.size() == 2);
58 |     REQUIRE(bytes[0] == static_cast<uint8_t>(0x30));
59 |     REQUIRE(bytes[1] == static_cast<uint8_t>(0x39));
60 |   }
61 | }


--------------------------------------------------------------------------------
/test/test_serialize_into_carray.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize into C-array" * test_suite("carray")) {
 8 |   uint8_t buf[10];
 9 | 
10 |   struct Foo {
11 |     int value;
12 |   };
13 |   Foo f{5};
14 | 
15 |   auto bytes_written = alpaca::serialize(f, buf);
16 |   REQUIRE(bytes_written == 1);
17 |   REQUIRE(buf[0] == 0x05);
18 | }
19 | 
20 | TEST_CASE("Serialize into C-array with version and checksum" *
21 |           test_suite("carray")) {
22 |   uint8_t buf[10];
23 | 
24 |   struct Foo {
25 |     int value;
26 |   };
27 |   Foo f{5};
28 | 
29 |   constexpr auto OPTIONS =
30 |       alpaca::options::with_version | alpaca::options::with_checksum;
31 |   auto bytes_written = alpaca::serialize<OPTIONS>(f, buf);
32 |   REQUIRE(bytes_written == 9);
33 |   REQUIRE(buf[4] == 0x05);
34 | }


--------------------------------------------------------------------------------
/test/test_serialize_map.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize map<char, int>" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::map<char, int> value;
10 |   };
11 | 
12 |   my_struct s{{{'x', 1}, {'y', 2}, {'z', 3}}};
13 |   std::vector<uint8_t> bytes;
14 |   serialize(s, bytes);
15 |   REQUIRE(bytes.size() == 7);
16 |   // size
17 |   REQUIRE(bytes[0] == static_cast<uint8_t>(3));
18 |   // key-value pairs
19 |   REQUIRE(bytes[1] == static_cast<uint8_t>('x'));
20 |   REQUIRE(bytes[2] == static_cast<uint8_t>(1));
21 |   REQUIRE(bytes[3] == static_cast<uint8_t>('y'));
22 |   REQUIRE(bytes[4] == static_cast<uint8_t>(2));
23 |   REQUIRE(bytes[5] == static_cast<uint8_t>('z'));
24 |   REQUIRE(bytes[6] == static_cast<uint8_t>(3));
25 | }
26 | 
27 | TEST_CASE("Serialize map<std::string, vector<int>>" * test_suite("map")) {
28 |   struct my_struct {
29 |     std::map<std::string, std::vector<int>> value;
30 |   };
31 | 
32 |   my_struct s{{{"time", {0, 1, 2, 3, 4}}, {"x", {5, 10, 15}}}};
33 |   std::vector<uint8_t> bytes;
34 |   serialize(s, bytes);
35 |   REQUIRE(bytes.size() == 18);
36 |   // size
37 |   REQUIRE(bytes[0] == static_cast<uint8_t>(2));
38 | 
39 |   // first key
40 |   REQUIRE(bytes[1] == static_cast<uint8_t>(4));
41 |   REQUIRE(bytes[2] == static_cast<uint8_t>('t'));
42 |   REQUIRE(bytes[3] == static_cast<uint8_t>('i'));
43 |   REQUIRE(bytes[4] == static_cast<uint8_t>('m'));
44 |   REQUIRE(bytes[5] == static_cast<uint8_t>('e'));
45 | 
46 |   // first value
47 |   // vector size
48 |   REQUIRE(bytes[6] == static_cast<uint8_t>(5));
49 |   // vector values
50 |   REQUIRE(bytes[7] == static_cast<uint8_t>(0));
51 |   REQUIRE(bytes[8] == static_cast<uint8_t>(1));
52 |   REQUIRE(bytes[9] == static_cast<uint8_t>(2));
53 |   REQUIRE(bytes[10] == static_cast<uint8_t>(3));
54 |   REQUIRE(bytes[11] == static_cast<uint8_t>(4));
55 | 
56 |   // next key
57 |   REQUIRE(bytes[12] == static_cast<uint8_t>(1));
58 |   REQUIRE(bytes[13] == static_cast<uint8_t>('x'));
59 | 
60 |   // next value
61 |   // vector size
62 |   REQUIRE(bytes[14] == static_cast<uint8_t>(3));
63 |   // vector values
64 |   REQUIRE(bytes[15] == static_cast<uint8_t>(5));
65 |   REQUIRE(bytes[16] == static_cast<uint8_t>(10));
66 |   REQUIRE(bytes[17] == static_cast<uint8_t>(15));
67 | }


--------------------------------------------------------------------------------
/test/test_serialize_map_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize map<char, int> into array" * test_suite("map")) {
 8 |   struct my_struct {
 9 |     std::map<char, int> value;
10 |   };
11 | 
12 |   my_struct s{{{'x', 1}, {'y', 2}, {'z', 3}}};
13 |   std::array<uint8_t, 20> bytes;
14 |   auto bytes_written = serialize(s, bytes);
15 |   REQUIRE(bytes_written == 7);
16 |   // size
17 |   REQUIRE(bytes[0] == static_cast<uint8_t>(3));
18 |   // key-value pairs
19 |   REQUIRE(bytes[1] == static_cast<uint8_t>('x'));
20 |   REQUIRE(bytes[2] == static_cast<uint8_t>(1));
21 |   REQUIRE(bytes[3] == static_cast<uint8_t>('y'));
22 |   REQUIRE(bytes[4] == static_cast<uint8_t>(2));
23 |   REQUIRE(bytes[5] == static_cast<uint8_t>('z'));
24 |   REQUIRE(bytes[6] == static_cast<uint8_t>(3));
25 | }
26 | 
27 | TEST_CASE("Serialize map<std::string, vector<int>> into array" *
28 |           test_suite("map")) {
29 |   struct my_struct {
30 |     std::map<std::string, std::vector<int>> value;
31 |   };
32 | 
33 |   my_struct s{{{"time", {0, 1, 2, 3, 4}}, {"x", {5, 10, 15}}}};
34 |   std::array<uint8_t, 20> bytes;
35 |   auto bytes_written = serialize(s, bytes);
36 |   REQUIRE(bytes_written == 18);
37 |   // size
38 |   REQUIRE(bytes[0] == static_cast<uint8_t>(2));
39 | 
40 |   // first key
41 |   REQUIRE(bytes[1] == static_cast<uint8_t>(4));
42 |   REQUIRE(bytes[2] == static_cast<uint8_t>('t'));
43 |   REQUIRE(bytes[3] == static_cast<uint8_t>('i'));
44 |   REQUIRE(bytes[4] == static_cast<uint8_t>('m'));
45 |   REQUIRE(bytes[5] == static_cast<uint8_t>('e'));
46 | 
47 |   // first value
48 |   // vector size
49 |   REQUIRE(bytes[6] == static_cast<uint8_t>(5));
50 |   // vector values
51 |   REQUIRE(bytes[7] == static_cast<uint8_t>(0));
52 |   REQUIRE(bytes[8] == static_cast<uint8_t>(1));
53 |   REQUIRE(bytes[9] == static_cast<uint8_t>(2));
54 |   REQUIRE(bytes[10] == static_cast<uint8_t>(3));
55 |   REQUIRE(bytes[11] == static_cast<uint8_t>(4));
56 | 
57 |   // next key
58 |   REQUIRE(bytes[12] == static_cast<uint8_t>(1));
59 |   REQUIRE(bytes[13] == static_cast<uint8_t>('x'));
60 | 
61 |   // next value
62 |   // vector size
63 |   REQUIRE(bytes[14] == static_cast<uint8_t>(3));
64 |   // vector values
65 |   REQUIRE(bytes[15] == static_cast<uint8_t>(5));
66 |   REQUIRE(bytes[16] == static_cast<uint8_t>(10));
67 |   REQUIRE(bytes[17] == static_cast<uint8_t>(15));
68 | }


--------------------------------------------------------------------------------
/test/test_serialize_nested_struct.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize nested struct (1 level)" * test_suite("struct")) {
 8 |   struct my_struct {
 9 |     int value;
10 | 
11 |     struct nested_struct {
12 |       float value;
13 |     };
14 |     nested_struct nested;
15 |   };
16 | 
17 |   my_struct s;
18 |   s.value = 5;
19 |   s.nested.value = 3.14f;
20 | 
21 |   std::vector<uint8_t> bytes;
22 |   serialize(s, bytes);
23 |   REQUIRE(bytes.size() == 5);
24 | 
25 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
26 |   // 3.14f
27 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xc3));
28 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0xf5));
29 |   REQUIRE(bytes[3] == static_cast<uint8_t>(0x48));
30 |   REQUIRE(bytes[4] == static_cast<uint8_t>(0x40));
31 | }
32 | 
33 | TEST_CASE("Serialize nested struct (2 levels)" * test_suite("struct")) {
34 |   struct my_struct {
35 |     int value;
36 | 
37 |     struct nested_struct {
38 |       float value;
39 | 
40 |       struct nested_nested_struct {
41 |         bool value;
42 |       };
43 |       nested_nested_struct nested;
44 |     };
45 |     nested_struct nested;
46 |   };
47 | 
48 |   my_struct s;
49 |   s.value = 5;
50 |   s.nested.value = 3.14f;
51 |   s.nested.nested.value = true;
52 | 
53 |   std::vector<uint8_t> bytes;
54 |   serialize(s, bytes);
55 |   REQUIRE(bytes.size() == 6);
56 | 
57 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
58 |   // 3.14f
59 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xc3));
60 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0xf5));
61 |   REQUIRE(bytes[3] == static_cast<uint8_t>(0x48));
62 |   REQUIRE(bytes[4] == static_cast<uint8_t>(0x40));
63 |   REQUIRE(bytes[5] == static_cast<uint8_t>(true));
64 | }


--------------------------------------------------------------------------------
/test/test_serialize_nested_struct_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize nested struct (1 level) into array" *
 8 |           test_suite("struct")) {
 9 |   struct my_struct {
10 |     int value;
11 | 
12 |     struct nested_struct {
13 |       float value;
14 |     };
15 |     nested_struct nested;
16 |   };
17 | 
18 |   my_struct s;
19 |   s.value = 5;
20 |   s.nested.value = 3.14f;
21 | 
22 |   std::array<uint8_t, 10> bytes;
23 |   auto bytes_written = serialize(s, bytes);
24 |   REQUIRE(bytes_written == 5);
25 | 
26 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
27 |   // 3.14f
28 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xc3));
29 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0xf5));
30 |   REQUIRE(bytes[3] == static_cast<uint8_t>(0x48));
31 |   REQUIRE(bytes[4] == static_cast<uint8_t>(0x40));
32 | }
33 | 
34 | TEST_CASE("Serialize nested struct (2 levels) into array" *
35 |           test_suite("struct")) {
36 |   struct my_struct {
37 |     int value;
38 | 
39 |     struct nested_struct {
40 |       float value;
41 | 
42 |       struct nested_nested_struct {
43 |         bool value;
44 |       };
45 |       nested_nested_struct nested;
46 |     };
47 |     nested_struct nested;
48 |   };
49 | 
50 |   my_struct s;
51 |   s.value = 5;
52 |   s.nested.value = 3.14f;
53 |   s.nested.nested.value = true;
54 | 
55 |   std::array<uint8_t, 10> bytes;
56 |   auto bytes_written = serialize(s, bytes);
57 |   REQUIRE(bytes_written == 6);
58 | 
59 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
60 |   // 3.14f
61 |   REQUIRE(bytes[1] == static_cast<uint8_t>(0xc3));
62 |   REQUIRE(bytes[2] == static_cast<uint8_t>(0xf5));
63 |   REQUIRE(bytes[3] == static_cast<uint8_t>(0x48));
64 |   REQUIRE(bytes[4] == static_cast<uint8_t>(0x40));
65 |   REQUIRE(bytes[5] == static_cast<uint8_t>(true));
66 | }


--------------------------------------------------------------------------------
/test/test_serialize_optional.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize optional<int>" * test_suite("optional")) {
 8 |   struct my_struct {
 9 |     std::optional<int> value;
10 |   };
11 | 
12 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
13 |   {
14 |     my_struct s{5};
15 |     std::vector<uint8_t> bytes;
16 |     serialize(s, bytes);
17 |     REQUIRE(bytes.size() == 0); // fail, number of fields in struct deduced as 0
18 |   }
19 | #endif
20 | 
21 |   {
22 |     my_struct s{5};
23 |     std::vector<uint8_t> bytes;
24 |     serialize<my_struct, 1>(s, bytes); // number of fields in struct specified
25 |     REQUIRE(bytes.size() == 2);
26 |     REQUIRE(bytes[0] == static_cast<uint8_t>(true)); // has_value
27 |     REQUIRE(bytes[1] == static_cast<uint8_t>(5));    // value = 5
28 |   }
29 | 
30 |   {
31 |     my_struct s{};
32 |     std::vector<uint8_t> bytes;
33 |     serialize<my_struct, 1>(s, bytes);
34 |     REQUIRE(bytes.size() == 1);
35 |     REQUIRE(bytes[0] == static_cast<uint8_t>(false));
36 |   }
37 | 
38 |   {
39 |     my_struct s{std::nullopt};
40 |     std::vector<uint8_t> bytes;
41 |     serialize<my_struct, 1>(s, bytes);
42 |     REQUIRE(bytes.size() == 1);
43 |     REQUIRE(bytes[0] == static_cast<uint8_t>(false));
44 |   }
45 | }


--------------------------------------------------------------------------------
/test/test_serialize_optional_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize optional<int> into array" * test_suite("optional")) {
 8 |   struct my_struct {
 9 |     std::optional<int> value;
10 |   };
11 | 
12 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
13 |   {
14 |     my_struct s{5};
15 |     std::array<uint8_t, 5> bytes;
16 |     auto bytes_written = serialize(s, bytes);
17 |     REQUIRE(bytes_written ==
18 |             0); // fail, number of fields in struct deduced as 0
19 |   }
20 | #endif
21 | 
22 |   {
23 |     my_struct s{5};
24 |     std::array<uint8_t, 5> bytes;
25 |     auto bytes_written = serialize<my_struct, 1>(
26 |         s, bytes); // number of fields in struct specified
27 |     REQUIRE(bytes_written == 2);
28 |     REQUIRE(bytes[0] == static_cast<uint8_t>(true)); // has_value
29 |     REQUIRE(bytes[1] == static_cast<uint8_t>(5));    // value = 5
30 |   }
31 | 
32 |   {
33 |     my_struct s{};
34 |     std::array<uint8_t, 5> bytes;
35 |     auto bytes_written = serialize<my_struct, 1>(s, bytes);
36 |     REQUIRE(bytes_written == 1);
37 |     REQUIRE(bytes[0] == static_cast<uint8_t>(false));
38 |   }
39 | 
40 |   {
41 |     my_struct s{std::nullopt};
42 |     std::array<uint8_t, 5> bytes;
43 |     auto bytes_written = serialize<my_struct, 1>(s, bytes);
44 |     REQUIRE(bytes_written == 1);
45 |     REQUIRE(bytes[0] == static_cast<uint8_t>(false));
46 |   }
47 | }


--------------------------------------------------------------------------------
/test/test_serialize_pair.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize pair" * test_suite("pair")) {
17 |   struct my_struct {
18 |     std::pair<int, double> value;
19 |   };
20 | 
21 |   my_struct s{std::make_pair(5, 3.14)};
22 |   std::vector<uint8_t> bytes;
23 |   serialize(s, bytes);
24 |   REQUIRE(bytes.size() == 9);
25 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
26 | 
27 |   // float
28 |   {
29 |     CONSTRUCT_EXPECTED_VALUE(double, 3.14);
30 |     for (std::size_t i = 0; i < expected.size(); ++i) {
31 |       REQUIRE(bytes[1 + i] == expected[i]);
32 |     }
33 |   }
34 | }


--------------------------------------------------------------------------------
/test/test_serialize_pair_optional.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize pair into array" * test_suite("pair")) {
17 |   struct my_struct {
18 |     std::pair<int, double> value;
19 |   };
20 | 
21 |   my_struct s{std::make_pair(5, 3.14)};
22 |   std::array<uint8_t, 10> bytes;
23 |   auto bytes_written = serialize(s, bytes);
24 |   REQUIRE(bytes_written == 9);
25 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
26 | 
27 |   // float
28 |   {
29 |     CONSTRUCT_EXPECTED_VALUE(double, 3.14);
30 |     for (std::size_t i = 0; i < expected.size(); ++i) {
31 |       REQUIRE(bytes[1 + i] == expected[i]);
32 |     }
33 |   }
34 | }


--------------------------------------------------------------------------------
/test/test_serialize_set.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | #include <set>
 4 | using namespace alpaca;
 5 | 
 6 | using doctest::test_suite;
 7 | 
 8 | TEST_CASE("Serialize set<int>" * test_suite("set")) {
 9 |   struct my_struct {
10 |     std::set<int> value;
11 |   };
12 | 
13 |   my_struct s{{1, 1, 1, 2, 3, 4}};
14 |   std::vector<uint8_t> bytes;
15 |   serialize(s, bytes);
16 |   REQUIRE(bytes.size() == 5);
17 |   // size
18 |   REQUIRE(bytes[0] == static_cast<uint8_t>(4));
19 |   // values
20 |   REQUIRE(bytes[1] == static_cast<uint8_t>(1));
21 |   REQUIRE(bytes[2] == static_cast<uint8_t>(2));
22 |   REQUIRE(bytes[3] == static_cast<uint8_t>(3));
23 |   REQUIRE(bytes[4] == static_cast<uint8_t>(4));
24 | }
25 | 
26 | TEST_CASE("Serialize unordered_set<int>" * test_suite("set")) {
27 |   struct my_struct {
28 |     std::unordered_set<int> value;
29 |   };
30 | 
31 |   my_struct s{{4, 3, 2, 1, 1, 1, 1, 2, 3, 4}};
32 |   std::vector<uint8_t> bytes;
33 |   serialize(s, bytes);
34 |   REQUIRE(bytes.size() == 5);
35 |   // size
36 |   REQUIRE(bytes[0] == static_cast<uint8_t>(4));
37 |   // values - order is unknown
38 |   // deserialization will confirm that all the values are
39 |   // correctly stored
40 | }


--------------------------------------------------------------------------------
/test/test_serialize_set_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | #include <set>
 4 | using namespace alpaca;
 5 | 
 6 | using doctest::test_suite;
 7 | 
 8 | TEST_CASE("Serialize set<int> into array" * test_suite("set")) {
 9 |   struct my_struct {
10 |     std::set<int> value;
11 |   };
12 | 
13 |   my_struct s{{1, 1, 1, 2, 3, 4}};
14 |   std::array<uint8_t, 10> bytes;
15 |   auto bytes_written = serialize(s, bytes);
16 |   REQUIRE(bytes_written == 5);
17 |   // size
18 |   REQUIRE(bytes[0] == static_cast<uint8_t>(4));
19 |   // values
20 |   REQUIRE(bytes[1] == static_cast<uint8_t>(1));
21 |   REQUIRE(bytes[2] == static_cast<uint8_t>(2));
22 |   REQUIRE(bytes[3] == static_cast<uint8_t>(3));
23 |   REQUIRE(bytes[4] == static_cast<uint8_t>(4));
24 | }
25 | 
26 | TEST_CASE("Serialize unordered_set<int> into array" * test_suite("set")) {
27 |   struct my_struct {
28 |     std::unordered_set<int> value;
29 |   };
30 | 
31 |   my_struct s{{4, 3, 2, 1, 1, 1, 1, 2, 3, 4}};
32 |   std::array<uint8_t, 10> bytes;
33 |   auto bytes_written = serialize(s, bytes);
34 |   REQUIRE(bytes_written == 5);
35 |   // size
36 |   REQUIRE(bytes[0] == static_cast<uint8_t>(4));
37 |   // values - order is unknown
38 |   // deserialization will confirm that all the values are
39 |   // correctly stored
40 | }


--------------------------------------------------------------------------------
/test/test_serialize_string.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize std::string" * test_suite("string")) {
 8 |   struct my_struct {
 9 |     std::string value;
10 |   };
11 | 
12 |   my_struct s{"Hello World!"};
13 |   std::vector<uint8_t> bytes;
14 |   serialize(s, bytes);
15 |   REQUIRE(bytes.size() == 1 + s.value.size());
16 |   REQUIRE(bytes[0] == static_cast<uint8_t>(12));
17 |   // Value
18 |   for (std::size_t i = 1; i < bytes.size() - 1; ++i) {
19 |     REQUIRE(bytes[i] == static_cast<uint8_t>(s.value[i - 1]));
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/test/test_serialize_string_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize std::string into array" * test_suite("string")) {
 8 |   struct my_struct {
 9 |     std::string value;
10 |   };
11 | 
12 |   my_struct s{"Hello World!"};
13 |   std::array<uint8_t, 15> bytes;
14 |   auto bytes_written = serialize(s, bytes);
15 |   REQUIRE(bytes_written == 1 + s.value.size());
16 |   REQUIRE(bytes[0] == static_cast<uint8_t>(12));
17 |   // Value
18 |   for (std::size_t i = 1; i < bytes_written; ++i) {
19 |     REQUIRE(bytes[i] == static_cast<uint8_t>(s.value[i - 1]));
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/test/test_serialize_to_fstream.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | #include <filesystem>
 4 | using namespace alpaca;
 5 | 
 6 | using doctest::test_suite;
 7 | 
 8 | TEST_CASE("Serialize complex struct to fstream" * test_suite("fstream")) {
 9 |   struct my_struct {
10 |     int a;
11 |     bool b;
12 |     char c;
13 |     std::string d;
14 |     std::vector<uint64_t> e;
15 |     std::map<std::string, std::array<uint8_t, 3>> f;
16 |   };
17 | 
18 |   my_struct s{5,
19 |               true,
20 |               'a',
21 |               "Hello World",
22 |               {6, 5, 4, 3, 2, 1},
23 |               {{"abc", {1, 2, 3}}, {"def", {4, 5, 6}}}};
24 | 
25 |   // Serialize to file
26 |   std::ofstream os;
27 |   os.open("tmp3.bin", std::ios::out | std::ios::binary);
28 |   auto bytes_written = serialize(s, os);
29 |   os.close();
30 |   REQUIRE(bytes_written == 37);
31 |   REQUIRE(std::filesystem::file_size("tmp3.bin") == 37);
32 |   std::filesystem::remove("tmp3.bin");
33 | }
34 | 
35 | TEST_CASE("Serialize complex struct to fstream with options" *
36 |           test_suite("fstream")) {
37 |   struct my_struct {
38 |     int a;
39 |     bool b;
40 |     char c;
41 |     std::string d;
42 |     std::vector<uint64_t> e;
43 |     std::map<std::string, std::array<uint8_t, 3>> f;
44 |   };
45 | 
46 |   my_struct s{5,
47 |               true,
48 |               'a',
49 |               "Hello World",
50 |               {6, 5, 4, 3, 2, 1},
51 |               {{"abc", {1, 2, 3}}, {"def", {4, 5, 6}}}};
52 | 
53 |   constexpr auto OPTIONS = options::big_endian | options::fixed_length_encoding;
54 | 
55 |   // Serialize to file
56 |   std::ofstream os;
57 |   os.open("tmp4.bin", std::ios::out | std::ios::binary);
58 |   auto bytes_written = serialize<OPTIONS>(s, os);
59 |   os.close();
60 |   constexpr auto expected_size =
61 |       93 + sizeof(alpaca::detail::size_t_serialized_type);
62 |   REQUIRE(bytes_written == expected_size);
63 |   REQUIRE(std::filesystem::file_size("tmp4.bin") == expected_size);
64 |   std::filesystem::remove("tmp4.bin");
65 | }


--------------------------------------------------------------------------------
/test/test_serialize_tuple.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize tuple<int, float, bool>" * test_suite("tuple")) {
17 |   struct my_struct {
18 |     std::tuple<int, float, bool, std::string, char> values;
19 |   };
20 | 
21 |   my_struct s{std::make_tuple(5, 3.14, true, "Hello", 'i')};
22 |   std::vector<uint8_t> bytes;
23 |   serialize(s, bytes);
24 |   REQUIRE(bytes.size() == 13);
25 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
26 | 
27 |   // float
28 |   {
29 |     CONSTRUCT_EXPECTED_VALUE(float, 3.14f);
30 |     for (std::size_t i = 0; i < expected.size(); ++i) {
31 |       REQUIRE(bytes[1 + i] == expected[i]);
32 |     }
33 |   }
34 | 
35 |   // bool
36 |   REQUIRE(bytes[5] == static_cast<uint8_t>(true));
37 | 
38 |   // string size
39 |   REQUIRE(bytes[6] == static_cast<uint8_t>(5));
40 | 
41 |   // string value
42 |   REQUIRE(bytes[7] == static_cast<uint8_t>('H'));
43 |   REQUIRE(bytes[8] == static_cast<uint8_t>('e'));
44 |   REQUIRE(bytes[9] == static_cast<uint8_t>('l'));
45 |   REQUIRE(bytes[10] == static_cast<uint8_t>('l'));
46 |   REQUIRE(bytes[11] == static_cast<uint8_t>('o'));
47 | 
48 |   // char
49 |   REQUIRE(bytes[12] == static_cast<uint8_t>('i'));
50 | }


--------------------------------------------------------------------------------
/test/test_serialize_tuple_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #define CONSTRUCT_EXPECTED_VALUE(type, value)                                  \
 8 |   type expected_value = value;                                                 \
 9 |   std::vector<uint8_t> expected;                                               \
10 |   std::copy(                                                                   \
11 |       static_cast<const char *>(static_cast<const void *>(&expected_value)),   \
12 |       static_cast<const char *>(static_cast<const void *>(&expected_value)) +  \
13 |           sizeof expected_value,                                               \
14 |       std::back_inserter(expected));
15 | 
16 | TEST_CASE("Serialize tuple<int, float, bool> into array" *
17 |           test_suite("tuple")) {
18 |   struct my_struct {
19 |     std::tuple<int, float, bool, std::string, char> values;
20 |   };
21 | 
22 |   my_struct s{std::make_tuple(5, 3.14, true, "Hello", 'i')};
23 |   std::array<uint8_t, 15> bytes;
24 |   auto bytes_written = serialize(s, bytes);
25 |   REQUIRE(bytes_written == 13);
26 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));
27 | 
28 |   // float
29 |   {
30 |     CONSTRUCT_EXPECTED_VALUE(float, 3.14f);
31 |     for (std::size_t i = 0; i < expected.size(); ++i) {
32 |       REQUIRE(bytes[1 + i] == expected[i]);
33 |     }
34 |   }
35 | 
36 |   // bool
37 |   REQUIRE(bytes[5] == static_cast<uint8_t>(true));
38 | 
39 |   // string size
40 |   REQUIRE(bytes[6] == static_cast<uint8_t>(5));
41 | 
42 |   // string value
43 |   REQUIRE(bytes[7] == static_cast<uint8_t>('H'));
44 |   REQUIRE(bytes[8] == static_cast<uint8_t>('e'));
45 |   REQUIRE(bytes[9] == static_cast<uint8_t>('l'));
46 |   REQUIRE(bytes[10] == static_cast<uint8_t>('l'));
47 |   REQUIRE(bytes[11] == static_cast<uint8_t>('o'));
48 | 
49 |   // char
50 |   REQUIRE(bytes[12] == static_cast<uint8_t>('i'));
51 | }


--------------------------------------------------------------------------------
/test/test_serialize_unique_ptr.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
 8 | 
 9 | template <class T> struct Node {
10 |   T data;
11 |   std::unique_ptr<Node<T>> left;
12 |   std::unique_ptr<Node<T>> right;
13 | };
14 | 
15 | template <class T>
16 | auto make_node(T const &value, std::unique_ptr<Node<T>> lhs = nullptr,
17 |                std::unique_ptr<Node<T>> rhs = nullptr) {
18 |   return std::unique_ptr<Node<T>>(
19 |       new Node<T>{value, std::move(lhs), std::move(rhs)});
20 | }
21 | 
22 | TEST_CASE("Serialize unique_ptr<struct>" * test_suite("unique_ptr")) {
23 | 
24 |   /*
25 |           5
26 |          / \
27 |         3   4
28 |        / \
29 |       1   2
30 |   */
31 | 
32 |   auto const root =
33 |       make_node(5, make_node(3, make_node(1), make_node(2)), make_node(4));
34 | 
35 |   std::vector<uint8_t> bytes;
36 |   serialize(*root, bytes);
37 |   REQUIRE(bytes.size() == 15);
38 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));  // root = 5
39 |   REQUIRE(bytes[1] == static_cast<uint8_t>(1));  // 5.has_left = true
40 |   REQUIRE(bytes[2] == static_cast<uint8_t>(3));  // 5.left = 3
41 |   REQUIRE(bytes[3] == static_cast<uint8_t>(1));  // 3.has_left = true
42 |   REQUIRE(bytes[4] == static_cast<uint8_t>(1));  // 3.left = 1
43 |   REQUIRE(bytes[5] == static_cast<uint8_t>(0));  // 1.left = null
44 |   REQUIRE(bytes[6] == static_cast<uint8_t>(0));  // 1.right = null
45 |   REQUIRE(bytes[7] == static_cast<uint8_t>(1));  // 3.has_right = true
46 |   REQUIRE(bytes[8] == static_cast<uint8_t>(2));  // 3.right = 2
47 |   REQUIRE(bytes[9] == static_cast<uint8_t>(0));  // 2.has_left = false
48 |   REQUIRE(bytes[10] == static_cast<uint8_t>(0)); // 2.has_right = false
49 |   REQUIRE(bytes[11] == static_cast<uint8_t>(1)); // 5.has_right = true
50 |   REQUIRE(bytes[12] == static_cast<uint8_t>(4)); // 5.right = 4
51 |   REQUIRE(bytes[13] == static_cast<uint8_t>(0)); // 4.has_left = false
52 |   REQUIRE(bytes[14] == static_cast<uint8_t>(0)); // 4.has_right = false
53 | }
54 | 
55 | #endif


--------------------------------------------------------------------------------
/test/test_serialize_unique_ptr_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | #if !defined(_MSC_VER) && !defined(__MINGW32__)
 8 | 
 9 | template <class T> struct Node {
10 |   T data;
11 |   std::unique_ptr<Node<T>> left;
12 |   std::unique_ptr<Node<T>> right;
13 | };
14 | 
15 | template <class T>
16 | auto make_node(T const &value, std::unique_ptr<Node<T>> lhs = nullptr,
17 |                std::unique_ptr<Node<T>> rhs = nullptr) {
18 |   return std::unique_ptr<Node<T>>(
19 |       new Node<T>{value, std::move(lhs), std::move(rhs)});
20 | }
21 | 
22 | TEST_CASE("Serialize unique_ptr<struct> into array" *
23 |           test_suite("unique_ptr")) {
24 | 
25 |   /*
26 |           5
27 |          / \
28 |         3   4
29 |        / \
30 |       1   2
31 |   */
32 | 
33 |   auto const root =
34 |       make_node(5, make_node(3, make_node(1), make_node(2)), make_node(4));
35 | 
36 |   std::array<uint8_t, 20> bytes;
37 |   auto bytes_written = serialize(*root, bytes);
38 |   REQUIRE(bytes_written == 15);
39 |   REQUIRE(bytes[0] == static_cast<uint8_t>(5));  // root = 5
40 |   REQUIRE(bytes[1] == static_cast<uint8_t>(1));  // 5.has_left = true
41 |   REQUIRE(bytes[2] == static_cast<uint8_t>(3));  // 5.left = 3
42 |   REQUIRE(bytes[3] == static_cast<uint8_t>(1));  // 3.has_left = true
43 |   REQUIRE(bytes[4] == static_cast<uint8_t>(1));  // 3.left = 1
44 |   REQUIRE(bytes[5] == static_cast<uint8_t>(0));  // 1.left = null
45 |   REQUIRE(bytes[6] == static_cast<uint8_t>(0));  // 1.right = null
46 |   REQUIRE(bytes[7] == static_cast<uint8_t>(1));  // 3.has_right = true
47 |   REQUIRE(bytes[8] == static_cast<uint8_t>(2));  // 3.right = 2
48 |   REQUIRE(bytes[9] == static_cast<uint8_t>(0));  // 2.has_left = false
49 |   REQUIRE(bytes[10] == static_cast<uint8_t>(0)); // 2.has_right = false
50 |   REQUIRE(bytes[11] == static_cast<uint8_t>(1)); // 5.has_right = true
51 |   REQUIRE(bytes[12] == static_cast<uint8_t>(4)); // 5.right = 4
52 |   REQUIRE(bytes[13] == static_cast<uint8_t>(0)); // 4.has_left = false
53 |   REQUIRE(bytes[14] == static_cast<uint8_t>(0)); // 4.has_right = false
54 | }
55 | 
56 | #endif


--------------------------------------------------------------------------------
/test/test_serialize_with_crc32.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize int with crc32" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   my_struct s{5};
13 |   std::vector<uint8_t> bytes;
14 |   serialize<options::with_checksum>(s, bytes);
15 | 
16 |   REQUIRE(bytes.size() == 5);
17 | 
18 |   REQUIRE(bytes[0] == static_cast<uint32_t>(0x05));
19 | 
20 |   // serializes in little endian
21 |   // 0x02 0x1b 0x68 0xa2
22 |   REQUIRE(bytes[1] == static_cast<uint32_t>(0x02));
23 |   REQUIRE(bytes[2] == static_cast<uint32_t>(0x1b));
24 |   REQUIRE(bytes[3] == static_cast<uint32_t>(0x68));
25 |   REQUIRE(bytes[4] == static_cast<uint32_t>(0xa2));
26 | }


--------------------------------------------------------------------------------
/test/test_serialize_with_crc32_into_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <alpaca/alpaca.h>
 2 | #include <doctest.hpp>
 3 | using namespace alpaca;
 4 | 
 5 | using doctest::test_suite;
 6 | 
 7 | TEST_CASE("Serialize int with crc32 into array" * test_suite("crc32")) {
 8 |   struct my_struct {
 9 |     int value;
10 |   };
11 | 
12 |   my_struct s{5};
13 | 
14 |   std::array<uint8_t, 10> bytes;
15 |   auto bytes_written = serialize<options::with_checksum>(s, bytes);
16 | 
17 |   REQUIRE(bytes_written == 5);
18 | 
19 |   REQUIRE(bytes[0] == static_cast<uint32_t>(0x05));
20 | 
21 |   // serializes in little endian
22 |   // 0x02 0x1b 0x68 0xa2
23 |   REQUIRE(bytes[1] == static_cast<uint32_t>(0x02));
24 |   REQUIRE(bytes[2] == static_cast<uint32_t>(0x1b));
25 |   REQUIRE(bytes[3] == static_cast<uint32_t>(0x68));
26 |   REQUIRE(bytes[4] == static_cast<uint32_t>(0xa2));
27 | }


--------------------------------------------------------------------------------