added endianness support

.gitignore

@@ -1,5 +1,3 @@
 .idea/
-.vs/
 build/
 cmake-build-debug/
-CTestConfig.cmake

.travis.yml

@@ -1,30 +0,0 @@
-language: cpp
-
-compiler:
-  - gcc
-  # clang
-
-before_install:
-  # C++14
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo apt-get update -qq
-
-install:
-  - sudo apt-get install -qq g++-5 lcov
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 90
-  - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 90
-  - wget https://github.com/google/googletest/archive/release-1.8.0.tar.gz
-  - tar xf release-1.8.0.tar.gz
-  - cd googletest-release-1.8.0
-  - cmake -DBUILD_SHARED_LIBS=ON .
-  - make
-  - sudo make install
-  - cd ..
-
-before_script:
-  - mkdir build
-  - cd build
-  - cmake -DBITSERY_BUILD_TESTS=ON ..
-
-script: make && (cd tests && ctest)
-

CHANGELOG.md

@@ -1,190 +1 @@
-# [4.2.1](https://github.com/fraillt/bitsery/compare/v4.2.0...v4.2.1) (2018-03-09)
-
-### Improvements
-* changed CMake structure, to follow **Modern CMake** principles.
-  * bitsery now has *install* target and **find_package(Bitsery)** exports **Bitsery::bitsery** target.
-  * *GTest* no longer downloads as external application, but tries to find via *find_package*.
-  * removed *ext* folder, and instead added *scripts* folder that contains few helper scripts for development, currently tested on Ubuntu.
-* fixed/added few tests cases.
-
-### Other notes
-* some work was done on polymorphism support, but current solution, although working, but has many design and performance issues, and interfaces for extensibility might change drastically.
-
-# [4.2.0](https://github.com/fraillt/bitsery/compare/v4.1.0...v4.2.0) (2017-11-12)
-
-### Features
-
-* serializer/deserializer can now have **internal context(s)** via configuration.
-It is convenient way to pass context, when it doesn't convey useful information outside of serializer/deserializer and is default constructable.
-* added **contextOrNull\<T\>()** overload to *BasicSerializer/BasicDeserializer*.
-Difference between *contextOrNull\<T\>()* and *context\<T\>()* is, that using *context\<T\>()* code doesn't compile if T doesn't exists at all, while using *contextOrNull\<T\>()* code compiles, but returns *nullptr* at runtime.
-* added inheritance support via extensions.
-In order to correctly manage virtual inheritance two extensions was created in **<bitsery/ext/inheritance.h>** header:
-  * **BaseClass\<TBase\>** - use when inheriting from objects without virtual inheritance.
-  * **VirtualBaseClass\<TBase\>** - ensures that only one copy of each virtual base class is serialized.
-
-  To keep track of virtual base classes **InheritanceContext** is required, but it is optional if no virtual bases exists in serialization flow.
-  I.e. if context is not defined, code will not compile only if virtual inheritance is used.
-  See [inheritance](examples/inheritance.cpp) for usage example.
-
-### Improvements
-* added optional ctor parameter for *PointerOwner* and *PointerObserver* - **PointerType**, which specifies if pointer can be null or not.
-Default is **Nullable**.
-
-# [4.1.0](https://github.com/fraillt/bitsery/compare/v4.0.1...v4.1.0) (2017-10-27)
-
-### Features
-* added raw pointers support via extensions.
-In order to correctly manage pointer ownership, three extensions was created in **<bitsery/ext/pointer.h>** header:
-  * **PointerOwner** - manages life time of the pointer, creates or destroys if required.
-  * **PointerObserver** - doesn't own pointer so it doesn't create or destroy anything.
-  * **ReferencedByPointer** - when non-owning pointer (*PointerObserver*) points to reference type, this extension marks this object as a valid target for PointerObserver.
-
-  To validate and update pointers **PointerLinkingContext** have to be passed to serialization/deserialization.
-  It ensures that all pointers are valid, that same pointer doesn't have multiple owners, and non-owning pointers doesn't point outside of scope (i.e. non owning pointers points to data that is serialized/deserialized), see [raw_pointers example](examples/raw_pointers.cpp) for usage example.
-
-  *Currently polimorphism and std::shared_ptr,  std::unique_ptr is not supported.*
-
-* added **context\<T\>()** overload to *BasicSerializer/BasicDeserializer* and now they became typesafe.
-For better extensions support, added posibility to have multiple types in context with *std::tuple*.
-E.g. when using multiple extensions, that requires specific contexts, together with your custom context, you can define your context as *std::tuple\<PointerLinkingContext, MyContext\>* and in serialization function you can correctly get your data via *context\<MyContext\>()*.
-
-
-### Improvements
-
-* new **OutputBufferedStreamAdapter** use internal buffer instead of directly writing to stream, can get more than 2x performance increase.
-  * can use any contiguous container as internal buffer.
-  * when using fixed-size, stack allocated container (*std::array*), buffer size via constructor is ignored.
-  * default internal buffer is *std::array<char,256>*.
-* added *static_assert* when trying to use *BufferAdapter* with non contiguous container.
-
-
-# [4.0.1](https://github.com/fraillt/bitsery/compare/v4.0.0...v4.0.1) (2017-10-18)
-
-### Improvements
-
-* improved usage with Visual Studio:
-  * improved CMake.
-  * Visual Studio doesn't properly support expression SFINAE using std::void_t, so it was rewritten.
-* refactorings to remove compiler warnings when using *-Wextra -Wno-missing-braces -Wpedantic -Weffc++*
-* added assertion when session is empty (sessions is created via *growable* extension).
-* stream adapter manually *setstate* to *std::ios_base::eofbit* when unable to read required bytes.
-
-# [4.0.0](https://github.com/fraillt/bitsery/compare/v3.0.0...v4.0.0) (2017-10-13)
-
-I feel that current library public API is complete, and should be stable for long time.
-Most changes was made to improve performance or/and make library usage easier.
-
-### Features
-
-* new **flexible** syntax similar to *cereal* library.
-This syntax no longer requires to specify explicit fundamental type sizes and container maxsize (container max size can be enforced by special function *maxSize*).
-Be careful when using deserializing untrusted data and make sure to enforce fundamental type sizes when using on multiple platforms.
-(use helper function *assertFundamentalTypeSizes* to enforce type sizes for multiple platforms)
-* added streaming support, by introducing new **adapter** concept. Two adapter implementations is available: stream adapter, or buffer adapter.
-* added missing std containers support: forward_list, deque, stack, queue, priority_queue, set, multiset, unordered_set, unordered_multiset.
-
-### Breaking changes
-
-* a lot of classes and files were renamed.
-* improved error messages.
-* traits reworked:
-  * ContainerTraits get **isContiguous**.
-  * TextTraits is separate from ContainerTraits, only has **length**, and **addNUL**.
-  * buffer traits renamed to **BufferAdapterTraits** and removed difference type.
-  * added **TValue** to all trait types, this is used to diagnose better errors.
-* BasicBufferReader/Writer is split in two different types: **AdapterReader/Writer** and separate type that enables bit-packing operations  **AdapterBitPacking(Reader/Writer)Wrapper**.
-* Serializer/Deserializer reworked
-  * No longer copyable, because it stores adapter writer/reader.
-  * Removed boolByte, boolBit, and added **boolValue** and it writes bit or byte, depeding on if bit-packing is enabled or not.
-  * Bit-packing is enabled by calling **enableBitPacking**, if bitpacking is already enabled, this method will return same instance.
-* changed defaults for *DefaultConfig*, BufferSessionsEnabled is false by default, because it doesn't work with input streams.
-* serialization config no longer needs typedef *Buffer*.
-
-# [3.0.0](https://github.com/fraillt/bitsery/compare/v2.0.1...v3.0.0) (2017-09-21)
-
-### Features
-
-* refactored interface, now works with C++11 compiler.
-* new new extension **Growable**, that allows to have forward/backward compatability within this functions serialization flow. It only allows to append new data at the end of to existing flow without breaking old consumers.
-  * old consumer: correctly read old interfce and ignore new data.
-  * new consumer: get defaults (zero values) for new fields, when reading old data.
-* added new extension for associative *map* containers **ContainerMap**.
-* friendly static_assert message when serializing **object**, that doesn't have **serialize** function defined.
-* added **object** overload, that invokes user function/lambda with object. It is the same as calling user function directly, but makes more consistent API.
-* Serializer/Deserializer now have optional *context* parameter, that might be required in some specific serialization cases.
-* added traits for custom types specialization, in *details/traits.h*
-* improved serialization performance: added support for fixed size buffer for BufferWriter for best performance.
-* improved performance for reading/writing container sizes.
-* added new method to BufferReader **getError** which returns on of three values: NO_ERROR, BUFFER_OVERFLOW, INVALID_BUFFER_DATA, also added setError method, that is only used by Deserializer.
-
-
-### Breaking changes
-
-* now all serializer/deserializer functions return void, to avoid undefined behaviour for functions parameters evaluation when using method chaining. There was no benefits apart from *nicer* syntax, but could have undefined behaviour when building complex serialization flows.
-* removed **SERIALIZE** macro, and changed interface for all functions that use custom lambdas, to work with C++11. Now lambda function must capture serializer/deserializer.
-* to make serializer a little bit *lighter* removed advanced features and made available as extensions via **extend** method
-  * removed **range** method, instead added **ValueRange** extension.
-  * removed **substitution** method, instead added **Entropy** extension, to sound more familiar to *entropy encoding* term.
-* removed **array**, instead added fixed sizes overloads for **container**.
-* removed **isValid** method from Deserializer, only BufferReader/Writer store states.
-* container and text sizes representation changed, to allow much faster size reads/writes for small values.
-* renamed functions:
-  * **ext** to **extend** and changed its interface, to make it more easy to extend.
-  * alias functions that write bytes directly no has *b* (meaning bytes) at the end of the name eg. *value4* now is *value4b*.
-* changed BufferWriter/Reader behaviour:
-  * added support for fixed size buffers for better serializer performance (more than 50% improvement). Default config is resizable buffer (*std::vector<uint8_t>*).
-  * after serialization, call *getWrittenRange* to get valid range written to buffer, because BufferWritter for resizable buffer now always resize to *capacity* to avoid using *back_insert_iterator* for better performance.
-  * BufferReader has constructor with iterators (range), and raw value type pointers (begin, end).
-* renamed BufferReader **isCompleted** to  **isCompletedSuccessfully**, that returns true only when there is no errors and buffer is fully read.
-
-### Bug fixes
-
-* **readBytes** was reading in aligned mode, when scratch value from previous bit operations was zero.
-* **writeBits** had incorrect assert when writing negative int64_t.
-
-<a name="2.0.1"></a>
-# [2.0.1](https://github.com/fraillt/bitsery/compare/v2.0.0...v2.0.1) (2017-08-12)
-
-### Other notes
-* added travis build status
-
-<a name="2.0.0"></a>
-# [2.0.0](https://github.com/fraillt/bitsery/compare/v1.1.1...v2.0.0) (2017-07-25)
-
-### Features
-
-* endianness support, default network configuration is *little endian*
-* added user extensible function **ext**, to work with objects that require different serialization/deserialization path (e.g. pointers)
-* **optional** extension (for *ext* function), to work with *std::optional* types
-
-### Bug Fixes
-* *align* method fixed in *BufferReader*
-
-### Breaking changes
-
-* file structure changed, added *details* folder.
-* no longer support for implicit size converions for all functions (*value*, *array*, *container*), instead added helper functions with specific size, to avoid typing *s.template value<1>...* within serialization function body
-* changed parameters order for all functions that use custom function (lambda)
-* *BufferReader* and *BufferWriter* is now alias types for real types *BasicBufferReader/Writer&lt;DefaultConfig&gt;* (*DefaultConfig* is defined in *common.h*)
-
-
-<a name="1.1.1"></a>
-# [1.1.1](https://github.com/fraillt/bitsery/compare/v1.0.0...v1.1.1) (2017-02-23)
-
-### Notes
-* changed folder structure
-* added more BufferReader constructors
-
-# 1.0.0 (2017-02-22)
-
-### Features
-
-Serialization functions:
-* **value** - [fundamental types](doc/design/fundamental_types.md)
-* **container** - dynamic size containers
-* **array** - fixed size containers
-* **text** - for c-array and std::string
-* **range** - compresion for fundamental types (e.g. int between [255..512] will take up 8bits
-* **substitution** - default value from list (e.g. 4d vector, that is most of the time equals to [0,0,0,1] can store only 1bit)
-* **boolBit**/**boolByte** - serialize bool, as 1bit or 1byte.
+#

CMakeLists.txt

@@ -1,64 +1,12 @@
-cmake_minimum_required(VERSION 3.1)
-project(bitsery
-        LANGUAGES CXX
-        VERSION 4.2.1)
+cmake_minimum_required(VERSION 3.2)
 
-#======== build options ===================================
-option(BITSERY_BUILD_EXAMPLES "Build examples" OFF)
-option(BITSERY_BUILD_TESTS "Build tests" OFF)
+project(bitsery)
 
-#============= setup target ======================
-add_library(bitsery INTERFACE)
-# create alias, so that user could always write target_link_libraries(... Bitsery::bitsery)
-# despite of bitsery target is imported or not
-add_library(Bitsery::bitsery ALIAS bitsery)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-include(GNUInstallDirs)
-target_include_directories(bitsery INTERFACE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-target_compile_features(bitsery INTERFACE
-        cxx_auto_type
-        cxx_constexpr
-        cxx_lambdas
-        cxx_nullptr
-        cxx_variadic_templates)
+add_subdirectory(examples)
 
-#=============== setup installation =======================
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/BitseryConfigVersion.cmake
-        COMPATIBILITY SameMajorVersion)
-install(TARGETS bitsery
-        EXPORT bitseryTargets
-        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(EXPORT bitseryTargets
-        FILE "BitseryConfig.cmake"
-        NAMESPACE Bitsery::
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/bitsery)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/BitseryConfigVersion.cmake
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/bitsery)
-install(DIRECTORY include/bitsery
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-#================ handle sub-projects =====================
-# examples and tests are independend directories, that can be built separatelly.
-# make find_package to no-op, when searching for "Bitsery", because it is created here.
-macro(find_package)
-    if (NOT ${ARGV0} STREQUAL Bitsery)
-        _find_package(${ARGV})
-    endif()
-endmacro()
-
-if (BITSERY_BUILD_EXAMPLES)
-    message("build bitsery examples")
-    add_subdirectory(examples)
-else()
-    message("skip bitsery examples")
-endif()
-
-if (BITSERY_BUILD_TESTS)
-    message("build bitsery tests")
-    add_subdirectory(tests)
-else()
-    message("skip bitsery tests")
-endif()
+enable_testing()
+add_subdirectory(tests)

CONTRIBUTING.md

@@ -1,31 +0,0 @@
-# Contributing to Bitsery
-
-So you want to contribute something to Bitsery? That's great!
-Contributions are always very much appreciated, whether it's a bug fix, a new feature or documentation.
-However, to make sure the process of accepting patches goes smoothly, you should try to follow these few simple guidelines when
-you contribute:
-
-1. Fork the repository.
-2. Create new branch based on the *master* branch (`git checkout -b your_branch master`). If your contribution is a bug fix, you should name your branch `bugfix/xxx`; for a feature, it should be `feature/xxx`. Otherwise, just use your good judgment. Consistent naming of branches is appreciated since it makes the output of `git branch` easier to understand with a single glance.
-3. Do your modifications on that branch. Except for special cases, your contribution should include proper unit tests and documentation.
-4. Make sure your modifications did not break anything by building, running tests:
-  ```shell
-  mkdir build
-  cd build
-  cmake -DBITSERY_BUILD_TESTS=ON ..
-  make
-  (cd tests; ctest)
-  ```
-  or run CTest scripts and view code coverage (scripts tested on ubuntu, requires lcov for coverage):
-  ```shell
-  cd scripts
-  ctest -S build.bitsery.cmake
-  ./show_coverage.sh build
-  ```
-5. Commit your changes, and push to your fork (`git push origin your_branch`). Commit message should be one line short description. When applicable, please squash adjacent *wip* commits into a single *logical* commit.
-6. Open a pull request against Bitsery *master* branch. Currently ongoing development is on *master*. At some point an integration branch will be set-up, and pull-requests should target that, but for now its all against master. You may see feature branches come and go, too.
-
-
-## Style guide
-
-Just use your own judgment and stick to the style of the surrounding code.

README.md

@@ -1,108 +1,77 @@
 # Bitsery
 
-[![Build Status](https://travis-ci.org/fraillt/bitsery.svg?branch=master)](https://travis-ci.org/fraillt/bitsery)
-[![Join the chat at https://gitter.im/bitsery/Lobby](https://badges.gitter.im/bitsery/Lobby.svg)](https://gitter.im/bitsery/Lobby)
-
 Header only C++ binary serialization library.
-It is designed around the networking requirements for real-time data delivery, especially for games.
+It is designed around the networking requirements for multiplayer real-time fast paced games as first person shooters.
+All cross-platform requirements are enforced at compile time, so serialized data do not store any run-time type information and is as small as possible.
 
-All cross-platform requirements are enforced at compile time, so serialized data do not store any meta-data information and is as small as possible.
+## Status
 
-> **bitsery** is looking for your feedback on [gitter](https://gitter.im/bitsery/Lobby)
+**bitsery** is in pre-release state and is looking for your feedback. 
+It has basic features, serialize arithmetic types, enums, containers and text, and few advanced features like value ranges and default values (substitution), but is still missing functions for delta changes and geometry compression.
+> Current version do not handle Big/Little Endianness.
+> Error handling on deserialization is not tested.
 
-## Features
-
-* Cross-platform compatible.
-* Optimized for speed and space.
-* No code generation required: no IDL or metadata, just use your types directly.
-* Runtime error checking on deserialization.
-* Can read/write from any source: stream (file, network stream. etc... ), or buffer (vector, c-array, etc...).
-* Don't pay for what you don't use! - customize your serialization via **extensions**. Some notable *extensions* allow:
-  * forward/backward compatibility for your types.
-  * raw pointers (no polymorphism yet).
-  * fine-grained bit-level serialization control.
-* Easily extendable for any type.
-* Allows flexible or/and verbose syntax for better serialization control.
-* Configurable endianess support.
-* No macros.
-
-## Why to use bitsery
-
-Look at the numbers and features list, and decide yourself.
-
-|                              | binary size | data size | serialize   | deserialize |
-|------------------------------|-------------|-----------|-------------|-------------|
-| **test_bitsery**             | 64704 B     | **7565 B**| **1229 ms** | **1086 ms** |
-| **test_bitsery_compression** | 64880 B     | **4784 B**| **1641 ms** | **2462 ms** |
-| test_yas                     | 63864 B     | 11311 B   | 1616 ms     | 1712 ms     |
-| test_yas_compression         | 72688 B     | 8523 B    | 2387 ms     | 2890 ms     |
-| test_cereal                  | 74848 B     | 11261 B   | 6708 ms     | 6799 ms     |
-| test_flatbuffers             | 67032 B     | 16100 B   | 8793 ms     | 3028 ms     |
-
-*benchmarked on Ubuntu with GCC 7.1.0, more details can be found [here](https://github.com/fraillt/cpp_serializers_benchmark.git)*
-
-If still not convinced read more in library [motivation](doc/design/README.md) section.
-
-## Usage example
+## Example
 ```cpp
+#include <iostream>
+#include <vector>
 #include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/traits/vector.h>
 
-enum class MyEnum:uint16_t { V1,V2,V3 };
+
+enum class MyEnum { V1,V2,V3 };
 struct MyStruct {
-    uint32_t i;
+    int i;
     MyEnum e;
     std::vector<float> fs;
 };
 
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);
-    s.value2b(o.e);
-    s.container4b(o.fs, 10);
-};
+//define how object should be serialized/deserialized
+SERIALIZE(MyStruct) {
+    return s.
+            value(o.i).
+            value(o.e).
+            container(o.fs, 100);
+}
 
 using namespace bitsery;
 
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
 int main() {
+    //set some random data
     MyStruct data{8941, MyEnum::V2, {15.0f, -8.5f, 0.045f}};
     MyStruct res{};
 
-    Buffer buffer;
+    //create serializer
+    //1) create buffer to store data
+    std::vector<uint8_t> buffer;
+    //2) create buffer writer that is able to write bytes or bits to buffer
+    BufferWriter bw{buffer};
+    //3) create serializer
+    Serializer<BufferWriter> ser{bw};
 
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
+    //serialize object, can also be invoked like this: serialize(ser, data)
+    ser.object(data);
 
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
+    //flush to buffer, before creating buffer reader
+    bw.flush();
 
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.fs == res.fs && data.i == res.i && data.e == res.e);
+    //create deserializer
+    //1) create buffer reader
+    BufferReader br{buffer};
+    //2) create deserializer
+    Deserializer<BufferReader> des{br};
+
+    //deserialize same object, can also be invoked like this: serialize(des, data)
+    des.object(res);
+
+    //check is equal
+    std::cout << "is equal: " << (data.fs == res.fs && data.i == res.i && data.e == res.e) << std::endl;
 }
 ```
-For more details go directly to [quick start](doc/tutorial/hello_world.md) tutorial.
-
-## How to use it
-This documentation comprises these parts:
-* [Tutorial](doc/tutorial/README.md) - getting started.
-* [Reference section](doc/README.md) - all the details.
-
-*documentation is in progress, most parts are empty, but [contributions](CONTRIBUTING.md) are welcome.*
-
-## Requirements
-
-Works with C++11 compiler, no additional dependencies, include `<bitsery/bitsery.h>` and you're done.
 
 ## Platforms
 
 This library was tested on
-* Windows: Visual Studio 2015, MinGW (GCC 5.2)
+* Windows: Visual Studio 2015, MinGW (gcc 5.2)
 * Linux: GCC 5.4, GCC 6.2, Clang 3.9
 * OS X Mavericks: AppleClang 8
 
-## License
-
-**bitsery** is licensed under the [MIT license](LICENSE).

doc/README.md

@@ -1,72 +0,0 @@
-To get the most out of **Bitsery**, start with the [tutorial](tutorial/README.md).
-Once you're familiar with the library consider the following reference material.
-
-Library design:
-* `fundamental types`
-* `valueNb instead of value`
-* `flexible syntax`
-* `serializer/deserializer functions overloads`
-* `extending library functionality`
-* `errors handling`
-* `forward/backward compatibility via Growable extension`
-* `pointers`
-* `inheritance`
-
-
-Core Serializer/Deserializer functions (alphabetical order):
-* `align`
-* `boolValue`
-* `container`
-* `ext`
-* `context`
-* `context<T>`
-* `contextOrNull<T>`
-* `object`
-* `text`
-* `value`
-
-Serializer/Deserializer extensions via `ext` method (alphabetical order):
-* `BaseClass`
-* `Entropy`
-* `Growable`
-* `PointerOwner`
-* `PointerObserver`
-* `ReferencedByPointer`
-* `StdMap`
-* `StdOptional`
-* `StdQueue`
-* `StdSet`
-* `StdStack`
-* `ValueRange`
-* `VirtualBaseClass`
-
-AdapterWriter/Reader functions:
-* `writeBits/readBits`
-* `writeBytes/readBytes`
-* `writeBuffer/readBuffer`
-* `align`
-* `beginSession/endSession`
-* `flush (writer only)`
-* `writtenBytesCount (writer only)`
-* `setError (reader only)`
-* `getError (reader only)`
-* `isCompletedSuccessfully (reader only)`
-
-Input adapters (buffer and stream) functions:
-* `read`
-* `error`
-* `setError`
-* `isCompletedSuccessfully`
-
-Output adapters (buffer and stream) functions:
-* `write`
-* `flush`
-* `writtenBytesCount` (buffer adapter only)
-
-
-Tips and tricks:
-* if you're getting static assert "please define 'serialize' function", most likely it is because your **serialize** function is not defined in same namespace as object.
-
-Other:
-* [Contributing](../CONTRIBUTING.md)
-* [Change log](../CHANGELOG.md)

doc/design/README.md

@@ -1,69 +0,0 @@
-## Motivation
-
-Inspiration to create **bitsery** came mainly because there aren't any good alternatives for C++.
-
-I wanted serializer that is easy to use like [cereal](http://uscilab.github.io/cereal/), is cross-platform compatible, and has support for forward/backward compatibility like [flatbuffers](https://google.github.io/flatbuffers/), is save to use with untrusted (malicious) data, and most importantly is fast and has small binary footprint.
-
-Furthermore I wanted full serialization control and ability to work on bit level, so I can further reduce data size. For example, serializing container of [quaternions](https://en.wikipedia.org/wiki/Quaternion) I can reduce size by large amount. *Size of orientation quaternion can be reduced from 128bits (4floats) down to 29bits using "smallest three" technique and still retaining decent precision*.
-
-Most well-known serialization libraries sacrifice memory and speed efficiency by supporting multiple data formats (binary, json, xml) and multiple languages (C++, C#, Javascript, etc..), these features also adds additional library complexity.
-
-## A word about JSON
-
-Often times people use C++ because they want speed and memory efficiency, and JSON is not on the list of efficient serialization format.
-Although JSON is very readable and very convenient when used together with dynamically typed languages such as JavaScript.
-When serializing data from statically typed languages, however, JSON not only has the obvious drawback of runtime inefficiency, but also forces you to write more code to access data (counterintuitively) due to its dynamic-typing serialization system.
-
-Adding optional support for JSON doesn't come for free either.
-To support JSON, additional metadata is required.
-In C++ it can be achieved by two ways:
-* with macros, that generate additional types like [cereal](http://uscilab.github.io/cereal/) does.
-* with code generation from IDL (interface definition language) like [flatbuffers](https://google.github.io/flatbuffers/) does.
-
-Both solutions adds additional complexity to the library. In the future C++ will get reflection system, currently static reflection was proposed to standard.
-
-So, to avoid unnecessary library complexity it is best to forget about JSON, and stick with what machines and C++ is good at, - binary format.
-
-# Bitsery
-
-Bitsery is designed to be lightweight and simple to use, yet powerful and extendable library.
-To ensure it works as intended it is unit tested, and has 100% code coverage.
-
-Now let's review features in more detail.
-
-* **Cross-platform compatible.** if same code compiles on Android, PS3 console, and your PC either x64 or x86 architecture, you are 100% sure it works.
-To achieve this, bitsery specifically defines size of underlying data, hence syntax is *value\<2\>* (alias function *value2b*)  instead or *value*, or *container2b* for element type of 16bits, eg int16_t.
-Bitsery also applies endianess transformation if nessesarry.
-* **Flexible syntax.** if you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b* you can use flexible syntax.
-Just include <bitsery/flexible.h> and can write like in [cereal](http://uscilab.github.io/cereal/).
-But do it on your own risk, and static assert using *assertFundamentalTypeSizes* function if you're planing to use it accross multiple platforms.
-* **Optimized for speed and space.** library itself doesn't do any allocations (except if you use backward/forward compatibility) so data writing/reading is fast as memcpy to/from your buffer.
-It also doesn't serialize any type information, all information needed is writen in your code!
-* **No code generation required: no IDL or metadata** since it doesn't support any other formats except binary, it doesn't need any metadata.
-* **Runtime error checking on deserialization** library designed to be save with untrusted network data, that's why all overloads that work on containers has *maxSize* value, unless container is static size like *std::array*, this way bitsery ensures that no malicious data crash you.
-* **Supports forward/backward compatibility for your types** library has optional forward/backward compatibility for types implemented in *AdapterReader/Writer* by allowing to have inner data sessions inside buffer.
-This is the only functionality that requires dynamic memory allocation.
-*Growable* extension use these sessions to add compatibility support for your types, in most basic form.
-You can implement your own extensions if you want to be able to add default values.
-* **2-in-1 declarative control flow, same code for serialization and deserialization.** only one function to define, for serialization and deserialization in same manner as *cereal* does.
-It might be handy to have separate *load* and *save* functions, but Bitsery explicitly doesn't support it, to avoid any serialization deserialization divergence, because it is very hard to catch an errors if you make a bug in one of these functions.
-The only way around this through extensions, write your custom flow once, and reuse where you need them.
-* **Allows fine-grained serialization control** this is a feature that no other libraries provides.
-Bitsery allows to use bit-level operations and has two extensions that use them:
-  * *ValueRange*,- if you have a *int16_t* data type, but you know that your object only stores values in \[0..1000\] range, it will write 10bits, instead of 16bits. ValueRanges also works with floats.
-  * *Entropy*,- full term is *entropy encoding*, which means that when you have most common value, or multiple values, it will write just few bits instead of full object.
-
-    Eg.: imagine that you have a struct Person{ int32_t Id; string Profession; }.
-    You might know that mostly there are young persons, so the most common value will be equal to: "Student", "Child", "NoProfession", in this case you'll pay 2bits for each record, but write no data if string matches.
-
-  Using these bit-level operations and extensions you can compose your own extensions for vectors, matrices or any other types.
-  Further more, all other operations will not align data automatically for you, so data will be compressed as much as possible.
-
-  * One more advanced and dangerous feature, is ability to have serialization context, so you can control your serialization flow at runtime, but make sure that these contexts are in sync between serializer and deserializer.
-    One possible use case for serialization context is to pass min/max ranges for *ValueRange* when your information changes at runtime.
-* **Easily extendable** library is designed to be easily extendable for any type and flow.
-You want to support your custom container, its fine there is *ContainerTraits* for this, only few methods required to implement.
-To use same container for buffer writing/reading add specialization to *BufferAdapterTraits*.
-You want to customize serialization flow - use extensions, only two methods to define, and *ExtensionTraits* to further customize usage.
-* **Configurable endianess support.** default is *Little Endian*, but if your primary target is PowerPC architecture, eg. PlayStation3, just change your configuration to be *Big Endian*.
-* **No macros.** Not so much to say, if you are like me, then it's a feature :)

doc/design/errors.md

@@ -1,2 +0,0 @@
-errors handling design
-usage of NotDefinedType, and how it helps to reduce error stack

doc/design/function_n.md

@@ -1 +0,0 @@
-valueN instead of value

doc/design/fundamental_types.md

@@ -1 +0,0 @@
-ints chars floats (except bool)

doc/reference/buf_get_error.md

@@ -1,6 +0,0 @@
-*document in progress*
-* NoError,
-* BUFFER_OVERFLOW,
-* INVALID_BUFFER_DATA
-* write what happens when data is corrupted
-* how growable effect error codes when deserializing old data format.

doc/reference/buf_is_completed_successfully.md

@@ -1,7 +0,0 @@
-### BufferReader.isCompletedSuccessfully()
-
-Returns true when buffer was fully read, and there was no [errors](buf_get_error.md).
-
-If buffer contains multiple serialized objects and you want to know deserialization state for each object, then use [getError](buf_get_error.md) after reading each object.
-
-Use this function when buffer contains one object, or you know that you read all data.

doc/tutorial/README.md

@@ -1,8 +0,0 @@
-The grand plan for this tutorial is to learn how to serialize/deserialize any object efficiently in time and space, so you could focus on other, more interesting things.
-
-This tutorial will cover these main topics:
-* `Hello World` write one control flow for both: serialization and deserialization.
-* `Composer` efficiently compose complex serialization flows.
-* `Squeeze Me!` compress your data when you know what it stores.
-* `Anything is Possible` extend library for custom container, compress geometry and more.
-* `Little or Big` change endianness if you want best performance on PowerPC.

doc/tutorial/composition.md

@@ -1,3 +0,0 @@
-*document in progress*
-* explain why *value* and *object* is fundamental functions.
-* write about *Growable* extension

doc/tutorial/hello_world.md

@@ -1,127 +0,0 @@
-# Quick Start
-
-This is a quick guide to get **bitsery** up and running in a matter of minutes.
-The only prerequisite for running bitsery is a modern C++11 compliant compiler, such as GCC 4.9.4, clang 3.4, MSVC 2015, or newer.
-Older versions might work, but it is not tested.
-
-## Get bitsery
-
-bitsery can be directly included in your project or installed anywhere you can access header files.
-Grab the latest version, and include directory `bitsery_base_dir/include/` to your project.
-There's nothing to build or make - **bitsery** is header only.
-
-## Include required headers and define some helper types
-
-```cpp
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/traits/vector.h>
-#include <bitsery/traits/string.h>
-
-using namespace bitsery;
-
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-```
-
-**bitsery** is very lightweight, so we need to explicitly include what we need.
-* `<bitsery/bitsery.h>` is a core header, that includes our Serializer and Deserializer
-* `<bitsery/adapter/buffer.h>` in order to write/read data we need specific adapter, depending on what underlying buffer will be. In this example we'll be using std::vector as our buffer, so we include buffer adapter.
-* <bitsery/traits/...> traits tells library how efficiently serialize particular container.
-
-create alias types for *InputAdapter* and *OutputAdapter* using our vector as buffer.
-
-## Add serialization method for your type
-
-**bitsery** needs to know which data members to serialize in your classes.
-Let it know by implementing a serialize method for your type:
-
-```cpp
-struct MyStruct {
-    uint32_t i;
-    char str[6];
-    std::vector<float> fs;
-};
-
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);
-    s.text1b(o.str);
-    s.container4b(o.fs, 100);
-};
-```
-
-**bitsery** also allows to define serialize function in side your class, and can also serialize private class members, just make *friend bitsery::Access;*
-
-**bitsery** supports two ways how to describe your serialization flow: *verbose syntax* (as in example) or *flexible syntax*, similar to *cereal* library, just include `<bitsery/flexible.h>` to use it.
-
-This example we choosed probably unfamiliar verbose syntax, so lets explain core functionality that you'll use all the time:
-* **s.value4b(o.i);** serialize fundamental types (ints, floats, enums) value**4b** means, that data type is 4 bytes. If you use same code on different machines, if it compiles it means it is compatible.
-* **s.text1b(o.str);** serialize text (null-terminated) of char type, if you use *wchar* then you would write *text2b*.
-* **s.container4b(o.fs, 100);** serializes any container of fundamental types of size 4bytes, **100** is max size of container.
-**Bitsery** is designed to be save with untrusted (malicious) data from network, so for dynamic containers you always need to provide max possible size available, to avoid buffer-overflow attacks.
-**text** didn't had this max size specified, because it was serializing fixed size container.
-
-External serialization functions should be placed either in the same namespace as the types they serialize or in the **bitsery** namespace so that the compiler can find them properly.
-
-## Serialization and deserialization
-
-Create buffer and use helper functions for serialization and deserialization.
-
-```cpp
-Buffer buffer;
-
-auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
-auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
-```
-
-These helper functions use default configuration *bitsery::DefaultConfig*
-* **quickSerialization** create serializer using output adapter, serializes data and returns written size.
-* **quickDeserialization** create deserializer using input adapter, deserializes to object, and returns deserialization state.
-deserialization state has two properties, error code and bool that indicates if buffer was fully read and there is no errors.
-
-## Full example code
-
-```cpp
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/traits/vector.h>
-#include <bitsery/traits/string.h>
-
-using namespace bitsery;
-
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-struct MyStruct {
-    uint32_t i;
-    char str[6];
-    std::vector<float> fs;
-};
-
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);
-    s.text1b(o.str);
-    s.container4b(o.fs, 100);
-};
-
-int main() {
-    MyStruct data{8941, "hello", {15.0f, -8.5f, 0.045f}};
-    MyStruct res{};
-
-    Buffer buffer;
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
-
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.fs == res.fs && data.i == res.i && std::strcmp(data.str, res.str) == 0);
-}
-```
-
-**currently documentation and tutorial is progress, but for more usage examples see examples folder**

examples/CMakeLists.txt

@@ -20,23 +20,16 @@
 #OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #SOFTWARE.
 
-cmake_minimum_required(VERSION 3.1)
-project(bitsery_examples CXX)
 
-if (NOT TARGET Bitsery::bitsery)
-    message(FATAL_ERROR "Bitsery::bitsery alias not set. Please generate CMake from bitsery root directory.")
-endif()
+cmake_minimum_required(VERSION 3.2)
+
+include_directories(${CMAKE_SOURCE_DIR}/include)
 
 file(GLOB ExampleFiles ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 
-if (WIN32)
-    message(WARNING "Removing example `flexible_assert_linux_x64` for Windows")
-    list(REMOVE_ITEM ExampleFiles ${CMAKE_CURRENT_SOURCE_DIR}/flexible_assert_linux_x64.cpp)
-endif()
-
-foreach(ExampleFile ${ExampleFiles})
+FOREACH(ExampleFile ${ExampleFiles})
     get_filename_component(ExampleName ${ExampleFile} NAME_WE)
-    add_executable(bitsery.example.${ExampleName} ${ExampleFile})
-    target_link_libraries(bitsery.example.${ExampleName} PRIVATE Bitsery::bitsery)
-endforeach()
+    add_executable(${ExampleName} ${ExampleFile})
+
+ENDFOREACH()
 

examples/basic_usage.cpp

@@ -1,50 +1,75 @@
-//include bitsery.h to get serialization and deserialization classes
-#include <bitsery/bitsery.h>
-//in ordered to serialize/deserialize data to buffer, include buffer adapter
-#include <bitsery/adapter/buffer.h>
-//bitsery itself doesn't is lightweight, and doesnt include any unnessessary files,
-//traits helps library to know how to use types correctly,
-//in this case we'll be using vector both, to serialize/deserialize data and to store use as a buffer.
-#include <bitsery/traits/vector.h>
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
 
-enum class MyEnum:uint16_t { V1,V2,V3 };
+#include <iostream>
+#include <vector>
+#include <bitsery/bitsery.h>
+
+
+enum class MyEnum { V1,V2,V3 };
 struct MyStruct {
-    uint32_t i;
+    int i;
     MyEnum e;
     std::vector<float> fs;
 };
 
 //define how object should be serialized/deserialized
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);//fundamental types (ints, floats, enums) of size 4b
-    s.value2b(o.e);
-    s.container4b(o.fs, 10);//resizable containers also requires maxSize, to make it safe from buffer-overflow attacks
+SERIALIZE(MyStruct) {
+    return s.
+            value4(o.i).
+            value4(o.e).
+            container4(o.fs, 100);
 }
 
 using namespace bitsery;
 
-//some helper types
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
 int main() {
     //set some random data
     MyStruct data{8941, MyEnum::V2, {15.0f, -8.5f, 0.045f}};
     MyStruct res{};
 
-    //create buffer to store data
-    Buffer buffer;
-    //use quick serialization function,
-    //it will use default configuration to setup all the nesessary steps
-    //and serialize data to container
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
+    //create serializer
+    //1) create buffer to store data
+    std::vector<uint8_t> buffer;
+    //2) create buffer writer that is able to write bytes or bits to buffer
+    BufferWriter bw{buffer};
+    //3) create serializer
+    Serializer<BufferWriter> ser{bw};
 
-    //same as serialization, but returns deserialization state as a pair
-    //first = error code, second = is buffer was successfully read from begin to the end.
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
+    //serialize object, can also be invoked like this: serialize(ser, data)
+    ser.object(data);
 
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.fs == res.fs && data.i == res.i && data.e == res.e);
-}
+    //flush to buffer, before creating buffer reader
+    bw.flush();
+
+    //create deserializer
+    //1) create buffer reader
+    BufferReader br{buffer};
+    //2) create deserializer
+    Deserializer<BufferReader> des{br};
+
+    //deserialize same object, can also be invoked like this: serialize(des, data)
+    des.object(res);
+
+    //check is equal
+    std::cout << "is equal: " << (data.fs == res.fs && data.i == res.i && data.e == res.e) << std::endl;
+}

examples/bit_packing.cpp

@@ -1,64 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-//we'll be using std::array as a buffer type, so include traits for this
-#include <bitsery/traits/array.h>
-#include <bitsery/traits/string.h>
-#include <bitsery/traits/vector.h>
-//include extension that will allow to compress our data
-#include <bitsery/ext/value_range.h>
-
-namespace MyTypes {
-
-    struct Vec3 { float x, y, z; };
-
-    struct Monster {
-        Vec3 pos;
-        std::vector<Vec3> path;
-        std::string name;
-    };
-
-    template<typename S>
-    void serialize(S& s, MyTypes::Vec3 &o) {
-        s.value4b(o.x);
-        s.value4b(o.y);
-        s.value4b(o.z);
-    }
-
-    template <typename S>
-    void serialize (S& s, Monster& o) {
-        s.text1b(o.name, 20);
-        s.object(o.pos);
-        //compress path in a range of -1.0 .. 1.0 with 0.01 precision
-        //enableBitPacking creates separate serializer/deserializer object, that contains bit packing operations
-        s.enableBitPacking([&o](typename S::BPEnabledType& sbp) {
-            sbp.container(o.path, 1000, [&sbp](Vec3& vec3) {
-                constexpr bitsery::ext::ValueRange<float> range{-1.0f,1.0f, 0.01f};
-                sbp.ext(vec3.x, range);
-                sbp.ext(vec3.y, range);
-                sbp.ext(vec3.z, range);
-            });
-        });
-    }
-}
-
-using namespace bitsery;
-
-//use fixed-size buffer
-using Buffer = std::array<uint8_t, 10000>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-int main() {
-    //set some random data
-    MyTypes::Monster data{};
-    data.name = "lew";
-
-    //create buffer to store data to
-    Buffer buffer{};
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
-    MyTypes::Monster res{};
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
-
-    assert(state.first == ReaderError::NoError && state.second);
-}

examples/context_usage.cpp

@@ -1,105 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-
-#include <bitsery/traits/string.h>
-#include <bitsery/traits/vector.h>
-
-#include <bitsery/ext/value_range.h>
-
-namespace MyTypes {
-
-    struct Monster {
-        Monster() = default;
-        Monster(std::string _name, uint32_t minDmg, uint32_t maxDmg)
-                :name{_name}, minDamage{minDmg}, maxDamage{maxDmg} {}
-
-        std::string name{};
-        uint32_t minDamage{};
-        uint32_t maxDamage{};
-        //...
-    };
-
-    struct GameState {
-        std::vector<Monster> monsters;
-    };
-
-    //default flow for monster
-    template <typename S>
-    void serialize (S& s, Monster& o) {
-        s.text1b(o.name, 20);
-        s.value4b(o.minDamage);
-        s.value4b(o.maxDamage);
-    }
-
-    template<typename S>
-    void serialize(S& s, GameState &o) {
-        //we can have multiple types in context with std::tuple
-        //this cast also works if our context is the same as cast
-        auto maxMonsters = s.template context<int>();
-        //all data from context is always pointer
-        //if data type doesn't match then it will be compile time error
-        auto dmgRange = s.template context<std::pair<uint32_t, uint32_t>>();
-        s.container(o.monsters, *maxMonsters, [&s, dmgRange] (Monster& m) {
-            s.text1b(m.name, 20);
-            //we know min/max damage range for monsters, so we can use this range instead of full value
-            bitsery::ext::ValueRange<uint32_t> range{dmgRange->first, dmgRange->second};
-            //enable bit packing
-            s.enableBitPacking([&m, &range](typename S::BPEnabledType& sbp) {
-                sbp.ext(m.minDamage, range);
-                sbp.ext(m.maxDamage, range);
-            });
-        });
-    }
-
-}
-
-using namespace bitsery;
-
-//use fixed-size buffer
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-//context can contain multiple types
-//it would make more sense to define separate structure for context, but for sake of this example make it more complex
-//in serialization function we can cast it like this:
-//  s.template context<int>();
-//if we want to get whole tuple, just call s.context() without template paramter.
-//this templated version also works if our context is the same as cast:
-//  struct MyContext {...};
-//  ...
-//  s.template context<MyContext>();
-using Context = std::tuple<int, std::pair<uint32_t, uint32_t>>;
-
-int main() {
-
-    MyTypes::GameState data{};
-    data.monsters.push_back({"weaksy", 100, 200});
-    data.monsters.push_back({"bigsy", 500, 1000});
-    data.monsters.push_back({"tootoo", 350, 750});
-
-    //set context
-    Context ctx{};
-    //max monsters
-    std::get<0>(ctx) = 4;
-    //damage range
-    std::get<1>(ctx).first = 100;
-    std::get<1>(ctx).second = 1000;
-
-
-    //create buffer to store data to
-    Buffer buffer{};
-    //pass game mode object to serializer as context
-    BasicSerializer<AdapterWriter<OutputAdapter, bitsery::DefaultConfig>, Context> ser{buffer, &ctx};
-    ser.object(data);
-
-    auto& w = AdapterAccess::getWriter(ser);
-    w.flush();
-    auto writtenSize = w.writtenBytesCount();
-
-    MyTypes::GameState res{};
-    BasicDeserializer <AdapterReader<InputAdapter, bitsery::DefaultConfig>, Context> des { InputAdapter{buffer.begin(), writtenSize}, &ctx};
-    des.object(res);
-    auto& r = AdapterAccess::getReader(des);
-
-    assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
-}

examples/file_stream.cpp

@@ -1,60 +0,0 @@
-#include <bitsery/bitsery.h>
-//in order to work with streams include stream adapter
-#include <bitsery/adapter/stream.h>
-#include <fstream>
-#include <iostream>
-
-enum class MyEnum:uint16_t { V1,V2,V3 };
-struct MyStruct {
-    uint32_t i;
-    MyEnum e;
-    double f;
-};
-
-//define how object should be serialized/deserialized
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);
-    s.value2b(o.e);
-    s.value8b(o.f);
-}
-
-using namespace bitsery;
-
-//some helper types
-using Stream = std::fstream;
-
-int main() {
-    //set some random data
-    MyStruct data{8941, MyEnum::V2, 0.045};
-    MyStruct res{};
-
-    //open file stream for writing and reading
-    auto fileName = "test_file.bin";
-    Stream s{fileName, s.binary | s.trunc | s.out};
-    if (!s.is_open()) {
-        std::cout << "cannot open " << fileName << " for writing\n";
-        return 0;
-    }
-    //we cannot use quick serialization function, because streams cannot use writtenBytesCount method
-    //for serialization we can use buffered stream adapter, it can greatly improve performance for some streams
-    Serializer<OutputBufferedStreamAdapter> ser{s};
-    ser.object(data);
-    //flush to writer
-    AdapterAccess::getWriter(ser).flush();
-    s.close();
-    //reopen for reading
-
-    s.open(fileName, s.binary | s.in);
-    if (!s.is_open()) {
-        std::cout << "cannot open " << fileName << " for reading\n";
-        return 0;
-    }
-
-    //same as serialization, but returns deserialization state as a pair
-    //first = error code, second = is buffer was successfully read from begin to the end.
-    auto state = quickDeserialization<InputStreamAdapter>(s, res);
-
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.f == res.f && data.i == res.i && data.e == res.e);
-}

examples/flexible_assert_linux_x64.cpp

@@ -1,45 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/flexible.h>
-#include <bitsery/flexible/vector.h>
-
-
-struct MyStruct {
-    int i;
-    unsigned short s;
-    std::vector<long> vl;
-    long long ll;
-
-    template <typename S>
-    void serialize(S& s) {
-        //now we can use flexible syntax with
-        //member function has same name as parameter
-        s.archive(this->s, i, vl, ll);
-    }
-
-};
-
-
-using namespace bitsery;
-
-//some helper types
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-int main() {
-    //this will only work on linux or mac x64
-    bitsery::assertFundamentalTypeSizes<2,4,8,8>();
-    //set some random data
-    MyStruct data{8941, 3, {15l, -8l, 045l}, 8459845ll};
-    MyStruct res{};
-
-    //serialization, deserialization flow is unchanged as in basic usage
-    Buffer buffer;
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
-
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.vl == res.vl && data.s == res.s && data.i == res.i && data.ll == res.ll);
-}

examples/flexible_syntax.cpp

@@ -1,47 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-//include flexible header, to use flexible syntax
-#include <bitsery/flexible.h>
-//we also need additional traits to work with container types,
-//instead of including <bitsery/traits/vector.h> for vector traits, now we also need traits to work with flexible types.
-//so include everything from <bitsery/flexible/...> instead of <bitsery/traits/...>
-//otherwise we'll get static assert error, saying to define serialize function.
-#include <bitsery/flexible/vector.h>
-
-enum class MyEnum:uint16_t { V1,V2,V3 };
-struct MyStruct {
-    uint32_t i;
-    MyEnum e;
-    std::vector<float> fs;
-
-    //define serialize function as usual
-    template <typename S>
-    void serialize(S& s) {
-        //now we can use flexible syntax with
-        s.archive(i, e, fs);
-    }
-
-};
-
-
-using namespace bitsery;
-
-//some helper types
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-int main() {
-    //set some random data
-    MyStruct data{8941, MyEnum::V2, {15.0f, -8.5f, 0.045f}};
-    MyStruct res{};
-
-    //serialization, deserialization flow is unchanged as in basic usage
-    Buffer buffer;
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
-    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
-
-    assert(state.first == ReaderError::NoError && state.second);
-    assert(data.fs == res.fs && data.i == res.i && data.e == res.e);
-}

examples/forward_backward_compatibility.cpp

@@ -1,105 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-//include traits for types, that we'll be using
-#include <bitsery/traits/string.h>
-#include <bitsery/traits/array.h>
-#include <bitsery/traits/vector.h>
-//include extension that will allow to have backward/forward compatibility
-#include <bitsery/ext/growable.h>
-
-namespace MyTypes {
-
-    //define data
-    enum Color:uint8_t { Red, Green, Blue };
-
-    struct Vec3 { float x, y, z; };
-
-    struct Weapon {
-        std::string name{};
-        int16_t damage{};
-        Weapon() = default;
-        Weapon(const std::string& _name, int16_t dmg):name{_name}, damage{dmg} {}
-    private:
-        //define serialize function as private, and give access to bitsery
-        friend bitsery::Access;
-        template <typename S>
-        void serialize (S& s) {
-            //forward/backward compatibility for monsters
-            s.ext(*this, bitsery::ext::Growable{}, [&s](Weapon& o1) {
-                s.text1b(o1.name, 20);
-                s.value2b(o1.damage);
-            });
-        }
-    };
-
-    struct Monster {
-        Vec3 pos;
-        int16_t mana;
-        int16_t hp;
-        std::string name;
-        std::vector<uint8_t> inventory;
-        Color color;
-        std::vector<Weapon> weapons;
-        Weapon equipped;
-        std::vector<Vec3> path;
-    };
-
-    template <typename S>
-    void serialize(S& s, Vec3& o) {
-        s.value4b(o.x);
-        s.value4b(o.y);
-        s.value4b(o.z);
-    }
-
-    template <typename S>
-    void serialize (S& s, Monster& o) {
-        //forward/backward compatibility for monsters
-        s.ext(o, bitsery::ext::Growable{}, [&s](Monster& o1) {
-            s.value1b(o1.color);
-            s.value2b(o1.mana);
-            s.value2b(o1.hp);
-            s.object(o1.equipped);
-            s.object(o1.pos);
-            s.container(o1.path, 1000);
-            s.container(o1.weapons, 100);
-            s.container1b(o1.inventory, 50);
-            s.text1b(o1.name, 20);
-        });
-    }
-}
-
-using namespace bitsery;
-
-//use fixed-size buffer
-using Buffer = std::array<uint8_t, 10000>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-//create configuration that enables session support, to work with "growable" extension
-struct SessionsEnabled:public DefaultConfig {
-    static constexpr bool BufferSessionsEnabled = true;
-};
-
-int main() {
-    //set some random data
-    MyTypes::Monster data{};
-    data.name = "lew";
-    data.weapons.push_back(MyTypes::Weapon{"GoodWeapon", 100});
-
-    //create buffer to store data to
-    Buffer buffer{};
-    //since we're using different configuration, we cannot use quickSerialization function.
-    BasicSerializer<AdapterWriter<OutputAdapter, SessionsEnabled>> ser{OutputAdapter{buffer}};
-    ser.object(data);
-    auto& w = AdapterAccess::getWriter(ser);
-    w.flush();
-    auto writtenSize = w.writtenBytesCount();
-
-
-    MyTypes::Monster res{};
-    //deserialize
-    BasicDeserializer<AdapterReader<InputAdapter, SessionsEnabled>> des{InputAdapter{buffer.begin(), writtenSize}};
-    des.object(res);
-    auto& r = AdapterAccess::getReader(des);
-    assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
-}

examples/inheritance.cpp

@@ -1,117 +0,0 @@
-//
-//this example coverls all the corner cases that can happen using inherintace
-//in reality virtual inherintance is usually avoided, so your code would look much simpler.
-//
-
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/traits/vector.h>
-
-//include inheritance extension
-//this header contains two extensions, that specifies inheritance type of base class
-//  BaseClass - normal inheritance
-//  VirtualBaseClass - when virtual inheritance is used
-//in order for virtual inheritance to work, InheritanceContext is required.
-//it can be created either internally (via configuration) or externally (pointer to context).
-#include <bitsery/ext/inheritance.h>
-
-using bitsery::ext::BaseClass;
-using bitsery::ext::VirtualBaseClass;
-
-struct Base {
-    uint8_t x{};
-    //Base doesn't have to be polymorphic class, inheritance works at compile-time.
-};
-template <typename S>
-void serialize(S& s, Base& o) {
-    s.value1b(o.x);
-}
-
-struct Derive1:virtual Base {// virtually inherits from base
-    uint8_t y1{};
-};
-template <typename S>
-void serialize(S& s, Derive1& o) {
-    //define virtual inheritance, it will not compile if InheritanceContext is not defined in serializer/deserialzer
-    s.ext(o, VirtualBaseClass<Base>{});
-    s.value1b(o.y1);
-}
-
-//to make it more interesting, serialize private member
-struct Derived2:virtual Base {
-    explicit Derived2(uint8_t y):y2{y} {}
-
-    uint8_t getY2() const {
-        return y2;
-    };
-private:
-    friend bitsery::Access;
-    uint8_t y2{};
-    template <typename S>
-    void serialize(S& s) {
-        //notice virtual inheritance
-        s.ext(*this, VirtualBaseClass<Base>{});
-        s.value1b(y2);
-    }
-};
-
-struct MultipleInheritance: Derive1, Derived2 {
-    explicit MultipleInheritance(uint8_t y2):Derived2{y2} {}
-    uint8_t z{};
-};
-template <typename S>
-void serialize(S& s, MultipleInheritance& o) {
-    //has two bases, serialize them separately
-    s.ext(o, BaseClass<Derive1>{});
-    s.ext(o, BaseClass<Derived2>{});
-    s.value1b(o.z);
-}
-
-namespace bitsery {
-    // call to serialize function with Derived2 and MultipleInheritance is ambiguous,
-    // it matches two serialize functions: Base classes non-member fnc and Derived2 member fnc
-    // we need explicitly select which function to use
-    template <>
-    struct SelectSerializeFnc<Derived2>:UseMemberFnc {};
-
-    //multiple inheritance has non-member serialize function defined
-    template <>
-    struct SelectSerializeFnc<MultipleInheritance>:UseNonMemberFnc {};
-}
-
-using namespace bitsery;
-
-// since in this example we're using virtual inheritance we need InheritanceContext as well.
-// InheritanceContext is default constructable and has no useful information outside of serializer/deserializer
-// lets create it internally, via configuration
-struct ConfigWithContext:DefaultConfig {
-    //always add internal contexts to tuple
-    using InternalContext = std::tuple<ext::InheritanceContext>;
-};
-
-//some helper types
-using Buffer = std::vector<uint8_t>;
-using Writer = AdapterWriter<OutputBufferAdapter<Buffer>, ConfigWithContext>;
-using Reader = AdapterReader<InputBufferAdapter<Buffer>, ConfigWithContext>;
-
-int main() {
-
-    MultipleInheritance data{98};
-    data.x = 254;
-    data.y1 = 47;
-    data.z = 1;
-
-    Buffer buf{};
-
-    BasicSerializer<Writer> ser{OutputBufferAdapter<Buffer>{buf}, nullptr};
-    ser.object(data);
-    auto writtenSize = AdapterAccess::getWriter(ser).writtenBytesCount();
-
-    MultipleInheritance res{0};
-    BasicDeserializer<Reader> des{InputBufferAdapter<Buffer>{buf.begin(), writtenSize}};
-    des.object(res);
-    assert(AdapterAccess::getReader(des).error() == ReaderError::NoError && AdapterAccess::getReader(des).isCompletedSuccessfully());
-
-    assert(data.x == res.x && data.y1 == res.y1 && data.getY2() == res.getY2() && data.z == res.z);
-    assert(writtenSize == 4);//base is serialized once, because it is inherited virtually
-}

examples/raw_pointers.cpp

@@ -1,160 +0,0 @@
-#include <bitsery/bitsery.h>
-#include <bitsery/adapter/buffer.h>
-#include <bitsery/traits/vector.h>
-
-//include pointers extension
-//this header contains multiple extensions for different pointer types and pointer linking context,
-//that validates pointer ownership and checks if there are and no dangling pointers after serialization/deserialization.
-//dangling pointer in this context means, that non-owning pointer points to data, that was not serialized.
-#include <bitsery/ext/pointer.h>
-
-using bitsery::ext::ReferencedByPointer;
-using bitsery::ext::PointerObserver;
-using bitsery::ext::PointerOwner;
-using bitsery::ext::PointerType ;
-
-enum class MyEnum:uint16_t { V1,V2,V3 };
-struct MyStruct {
-    MyStruct(uint32_t i_, MyEnum e_, std::vector<float> fs_)
-            :i{i_},
-             e{e_},
-             fs{fs_} {}
-    MyStruct():MyStruct{0, MyEnum::V1, {}} {}
-    uint32_t i;
-    MyEnum e;
-    std::vector<float> fs;
-};
-
-template <typename S>
-void serialize(S& s, MyStruct& o) {
-    s.value4b(o.i);
-    s.value2b(o.e);
-    s.container4b(o.fs, 10);
-}
-
-//our test data
-struct Test1Data {
-    //regular data, nothing fancy here
-    MyStruct o1;
-    int32_t i1;
-    //these container elements can be referenced by pointers
-    std::vector<MyStruct> vdata;
-    //container that holds non owning pointers (observers),
-    std::vector<MyStruct*> vptr;
-    //treat it as is observer
-    MyStruct* po1;
-    //we treat this as owner (responsible for allocation/deallocation
-    int32_t* pi1;
-
-private:
-    friend bitsery::Access;
-
-    template <typename S>
-    void serialize(S& s) {
-        //just a regular fields
-        s.object(o1);
-        s.value4b(i1);
-
-        //set container elements to be candidates for non-owning pointers
-        s.container(vdata, 100, [&s](MyStruct& d){
-            s.ext(d, ReferencedByPointer{});
-        });
-        //contains non owning pointers
-        //
-        //IMPORTANT !!!
-        //ALWAYS ACCEPT BY REFERENCE like this: T* (&obj)
-        //if using c++14, then auto& always works.
-        //
-        //you can also serialize non owning pointers first, pointer linking context will keep track on them
-        //and as soon as pointer owner data is deserialized, all non-owning pointers will be updated
-        s.container(vptr, 100, [&s](MyStruct* (&d)){
-            s.ext(d, PointerObserver{});
-        });
-        //observer
-        s.ext(po1, PointerObserver{});
-        //owner, mark it as not null
-        s.ext4b(pi1, PointerOwner{PointerType::NotNull});
-
-    }
-};
-
-using namespace bitsery;
-
-//some helper types
-using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
-
-//we will need PointerLinkingContext to work with pointers
-//so lets define our serializer/deserializer
-//if we need context for our own custom flow, we can define it as tuple like this:
-//  std::tuple<MyContext,ext::PointerLinkingContext>
-//and other code will work as expected as long as it cast to proper type.
-//see context_usage.cpp for usage example
-using MySerializer = BasicSerializer<AdapterWriter<OutputAdapter, DefaultConfig>, ext::PointerLinkingContext>;
-using MyDeserializer = BasicDeserializer<AdapterReader<InputAdapter, DefaultConfig>, ext::PointerLinkingContext>;
-
-int main() {
-    //set some random data
-    Test1Data data{};
-    data.vdata.emplace_back(8941, MyEnum::V1, std::vector<float>{4.4f});
-    data.vdata.emplace_back(15478, MyEnum::V2, std::vector<float>{15.0f});
-    data.vdata.emplace_back(59, MyEnum::V3, std::vector<float>{-8.5f, 0.045f});
-    //container of non owning pointers (observers)
-    data.vptr.emplace_back(nullptr);
-    data.vptr.emplace_back(std::addressof(data.vdata[0]));
-    data.vptr.emplace_back(std::addressof(data.vdata[2]));
-    //regular fields
-    data.o1 = MyStruct{4, MyEnum::V2, {57.078f}};
-    data.i1 = 9455;
-    //observer
-    data.po1 = std::addressof(data.vdata[1]);
-    //owning pointer
-    data.pi1 = new int32_t{};
-
-    //create buffer to store data
-    Buffer buffer{};
-    size_t writtenSize{};
-    //in order to use pointers, we need to pass pointer linking context to serializer/deserializer
-    {
-        ext::PointerLinkingContext ctx{};
-        //pass lining context to serializer, by pointer
-        MySerializer ser{OutputAdapter{buffer}, &ctx};
-        //serialize our data
-        ser.object(data);
-        auto& w = AdapterAccess::getWriter(ser);
-        w.flush();
-        writtenSize = w.writtenBytesCount();
-
-        //make sure that pointer linking context is valid
-        //this ensures that all non-owning pointers points to data that has been serialized,
-        //so we can successfully reconstruct pointers after deserialization
-        assert(ctx.isValid());
-    }
-
-    Test1Data res{};
-    {
-        ext::PointerLinkingContext ctx{};
-        //pass lining context to deserializer, by pointer
-        MyDeserializer des{InputAdapter{buffer.begin(), writtenSize}, &ctx};
-        //deserialize our data
-        des.object(res);
-        auto& r = AdapterAccess::getReader(des);
-        //check if everything went find
-        assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
-        //also check for dangling pointers, after deserialization
-        assert(ctx.isValid());
-    }
-    //owning pointers owns data
-    assert(*res.pi1 == *data.pi1);
-    assert(res.pi1 != data.pi1);
-    //observers, points to other data
-    assert(res.vptr[0] == nullptr);
-    assert(res.vptr[1] == std::addressof(res.vdata[0]));
-    assert(res.vptr[2] == std::addressof(res.vdata[2]));
-    assert(res.po1 == std::addressof(res.vdata[1]));
-
-    //delete raw owning pointers
-    delete data.pi1;
-    delete res.pi1;
-}

ext/CodeCoverage.cmake

@@ -0,0 +1,198 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+			#extract only /include/bitsery directory
+		COMMAND ${LCOV_PATH} --extract ${coverage_info} '*include/bitsery*' --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA

ext/LinkTestLIb.cmake

@@ -0,0 +1,18 @@
+function(LinkTestLib TargetName)
+
+    add_dependencies(${TargetName} googletest)
+
+    if(NOT WIN32 OR MINGW)
+        FOREACH(LibName ${GTestLinkLibNames})
+            target_link_libraries(${TargetName} ${GTestLibsDir}/lib${LibName}.a )
+        ENDFOREACH()
+    else()
+        FOREACH(LibName ${GTestLinkLibNames})
+            target_link_libraries(${TargetName}
+                    debug ${GTestLibsDir}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LibName}${CMAKE_FIND_LIBRARY_SUFFIXES}
+                    optimized ${GTestLibsDir}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LibName}${CMAKE_FIND_LIBRARY_SUFFIXES})
+        ENDFOREACH()
+    endif()
+
+    target_link_libraries(${TargetName} ${CMAKE_THREAD_LIBS_INIT})
+endfunction(LinkTestLib)

ext/gtest/CMakeLists.txt

@@ -0,0 +1,79 @@
+#MIT License
+#
+#Copyright (c) 2017 Mindaugas Vinkelis
+#
+#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:
+#
+#The above copyright notice and this permission notice shall be included in all
+#copies or substantial portions of the Software.
+#
+#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.
+
+cmake_minimum_required(VERSION 3.2)
+project(gtest_builder C CXX)
+include(ExternalProject)
+
+set(ForceSharedCrt ON)
+set(DisablePThreads OFF)
+
+if(MINGW)
+    set(DisablePThreads ON)
+endif()
+
+if (${UseGMock})
+    message("use gmock")
+    set(BuildArgs -DBUILD_GTEST=OFF -DBUILD_GMOCK=ON)
+else ()
+    message("use gtest only")
+    set(BuildArgs -DBUILD_GTEST=ON -DBUILD_GMOCK=OFF)
+endif()
+
+if (WIN32 AND NOT MINGW)
+    set(BuildArgs ${BuildArgs}
+            -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG:PATH=DebugLibs
+            -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE:PATH=ReleaseLibs)
+endif()
+
+ExternalProject_Add(googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        CMAKE_ARGS ${BuildArgs}
+        -Dgtest_force_shared_crt=${ForceSharedCrt}
+        -Dgtest_disable_pthreads=${DisablePThreads}
+        PREFIX "${CMAKE_CURRENT_BINARY_DIR}"
+        # disable update command
+        UPDATE_COMMAND ""
+        # disable install step
+        INSTALL_COMMAND ""
+        )
+
+#export variables
+ExternalProject_Get_Property(googletest source_dir)
+ExternalProject_Get_Property(googletest binary_dir)
+if (${UseGMock})
+    # need to include both googletest and googlemock
+    set(GTestIncludeDirs ${source_dir}/googlemock/include ${source_dir}/googletest/include PARENT_SCOPE)
+    set(GTestLibsDir ${binary_dir}/googlemock PARENT_SCOPE)
+    set(GTestLibName gmock PARENT_SCOPE)
+    set(GTestMainLibName gmock_main PARENT_SCOPE)
+    set(GTestLinkLibNames gmock_main PARENT_SCOPE)
+else()
+    set(GTestIncludeDirs ${source_dir}/googletest/include PARENT_SCOPE)
+    set(GTestLibsDir ${binary_dir}/googletest PARENT_SCOPE)
+    set(GTestLibName gtest PARENT_SCOPE)
+    set(GTestMainLibName gtest_main PARENT_SCOPE)
+    # need to include both libs gtest and gtest_main
+    set(GTestLinkLibNames gtest gtest_main PARENT_SCOPE)
+endif()
+
+

include/bitsery/adapter/buffer.h

@@ -1,207 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_ADAPTER_BUFFER_H
-#define BITSERY_ADAPTER_BUFFER_H
-
-#include "../details/adapter_common.h"
-#include "../traits/core/traits.h"
-
-namespace bitsery {
-
-    //base class that stores container iterators, and is required for session support (for reading sessions data)
-    template <typename Buffer>
-    class BufferIterators {
-    protected:
-        using TIterator = typename traits::BufferAdapterTraits<Buffer>::TIterator;
-
-        BufferIterators(TIterator begin, TIterator end)
-                :posIt{begin},
-                 endIt{end}
-        {
-        }
-
-        friend details::SessionAccess;
-
-        TIterator posIt;
-        TIterator endIt;
-    };
-
-
-    template <typename Buffer>
-    class InputBufferAdapter: public BufferIterators<Buffer> {
-    public:
-
-        using TIterator = typename BufferIterators<Buffer>::TIterator;
-        using TValue = typename traits::BufferAdapterTraits<Buffer>::TValue;
-        static_assert(details::IsDefined<TValue>::value, "Please define BufferAdapterTraits or include from <bitsery/traits/...>");
-        static_assert(traits::ContainerTraits<Buffer>::isContiguous, "BufferAdapter only works with contiguous containers");
-
-        InputBufferAdapter(TIterator begin, TIterator end): BufferIterators<Buffer>(begin, end)
-        {
-        }
-
-        InputBufferAdapter(TIterator begin, size_t size)
-                :InputBufferAdapter(begin, std::next(begin, size))
-        {
-        }
-
-        void read(TValue* data, size_t size) {
-            //for optimization
-            auto tmp = this->posIt;
-            this->posIt += size;
-            if (std::distance(this->posIt, this->endIt) >= 0) {
-                std::memcpy(data, std::addressof(*tmp), size);
-            } else {
-                this->posIt -= size;
-                //set everything to zeros
-                std::memset(data, 0, size);
-
-                if (error() == ReaderError::NoError)
-                    setError(ReaderError::DataOverflow);
-            }
-        }
-
-        ReaderError error() const {
-            auto res = std::distance(this->endIt, this->posIt);
-            if (res > 0) {
-                auto err = static_cast<ReaderError>(res);
-                return err;
-            }
-            return ReaderError::NoError;
-        }
-
-        void setError(ReaderError error) {
-            this->endIt = this->posIt;
-            //to avoid creating temporary for error state, mark an error by passing posIt after the endIt
-            std::advance(this->posIt, static_cast<size_t>(error));
-        }
-
-        bool isCompletedSuccessfully() const {
-            return this->posIt == this->endIt;
-        }
-    };
-
-
-    template<typename Buffer>
-    class OutputBufferAdapter {
-    public:
-
-        using TIterator = typename traits::BufferAdapterTraits<Buffer>::TIterator;
-        using TValue = typename traits::BufferAdapterTraits<Buffer>::TValue;
-
-        static_assert(details::IsDefined<TValue>::value, "Please define BufferAdapterTraits or include from <bitsery/traits/...>");
-        static_assert(traits::ContainerTraits<Buffer>::isContiguous, "BufferAdapter only works with contiguous containers");
-
-        OutputBufferAdapter(Buffer &buffer)
-                : _buffer{std::addressof(buffer)}
-        {
-
-            init(TResizable{});
-        }
-
-
-        void write(const TValue *data, size_t size) {
-            writeInternal(data, size, TResizable{});
-        }
-
-        void flush() {
-            //this function might be useful for stream adapters
-        }
-
-        size_t writtenBytesCount() const {
-            return static_cast<size_t>(std::distance(std::begin(*_buffer), _outIt));
-        }
-
-    private:
-        using TResizable = std::integral_constant<bool, traits::ContainerTraits<Buffer>::isResizable>;
-
-        Buffer* _buffer;
-        TIterator _outIt{};
-        TIterator _end{};
-
-        /*
-         * resizable buffer
-         */
-
-        void init(std::true_type) {
-            //resize buffer immediately, because we need output iterator at valid position
-            if (traits::ContainerTraits<Buffer>::size(*_buffer) == 0u) {
-                traits::BufferAdapterTraits<Buffer>::increaseBufferSize(*_buffer);
-            }
-            _end = std::end(*_buffer);
-            _outIt = std::begin(*_buffer);
-        }
-
-        void writeInternal(const TValue *data, const size_t size, std::true_type) {
-            //optimization
-#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
-            using TDistance = typename std::iterator_traits<TIterator>::difference_type;
-            if (std::distance(_outIt , _end) >= static_cast<TDistance>(size)) {
-                std::memcpy(std::addressof(*_outIt), data, size);
-                _outIt += size;
-#else
-            auto tmp = _outIt;
-            _outIt += size;
-            if (std::distance(_outIt , _end) >= 0) {
-                std::memcpy(std::addressof(*tmp), data, size);
-#endif
-            } else {
-#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
-
-#else
-                _outIt -= size;
-#endif
-                //get current position before invalidating iterators
-                const auto pos = std::distance(std::begin(*_buffer), _outIt);
-                //increase container size
-                traits::BufferAdapterTraits<Buffer>::increaseBufferSize(*_buffer);
-                //restore iterators
-                _end = std::end(*_buffer);
-                _outIt = std::next(std::begin(*_buffer), pos);
-
-                writeInternal(data, size, std::true_type{});
-            }
-        }
-
-        /*
-         * non resizable buffer
-         */
-        void init(std::false_type) {
-            _outIt = std::begin(*_buffer);
-            _end = std::end(*_buffer);
-        }
-
-        void writeInternal(const TValue *data, size_t size, std::false_type) {
-            //optimization
-            auto tmp = _outIt;
-            _outIt += size;
-            assert(std::distance(_outIt, _end) >= 0);
-            memcpy(std::addressof(*tmp), data, size);
-        }
-    };
-
-
-}
-
-#endif //BITSERY_ADAPTER_BUFFER_H

include/bitsery/adapter/stream.h

@@ -1,227 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_ADAPTER_STREAM_H
-#define BITSERY_ADAPTER_STREAM_H
-
-#include "../details/adapter_common.h"
-#include "../traits/array.h"
-#include <ios>
-
-
-namespace bitsery {
-
-    template <typename TChar, typename CharTraits>
-    class BasicInputStreamAdapter {
-    public:
-        using TValue = TChar;
-        using TIterator = void;//TIterator is used with sessions, but streams cannot be used with sessions
-
-        BasicInputStreamAdapter(std::basic_ios<TChar, CharTraits>& istream)
-                :_ios{std::addressof(istream)} {}
-
-        void read(TValue* data, size_t size) {
-            if (static_cast<size_t>(_ios->rdbuf()->sgetn( data , size )) != size) {
-                *data = {};
-                //check state, if not set by stream, set it manually
-                if (_ios->good())
-                    _ios->setstate(std::ios_base::eofbit);
-            }
-
-        }
-
-        ReaderError error() const {
-            if (_ios->good())
-                return ReaderError::NoError;
-            return _ios->eof()
-                   ? ReaderError::DataOverflow
-                   : ReaderError::ReadingError;
-        }
-        bool isCompletedSuccessfully() const {
-            if (error() == ReaderError::NoError) {
-                return _ios->rdbuf()->sgetc() == CharTraits::eof();
-            }
-            return false;
-        }
-        void setError(ReaderError ) {
-            //has no effect when using
-        }
-
-    private:
-        std::basic_ios<TChar, CharTraits>* _ios;
-    };
-
-    template <typename TChar, typename CharTraits>
-    class BasicOutputStreamAdapter {
-    public:
-        using TValue = TChar;
-        using TIterator = void;//TIterator is used with sessions, but streams cannot be used with sessions
-
-        BasicOutputStreamAdapter(std::basic_ios<TChar, CharTraits>& ostream)
-                :_ios{std::addressof(ostream)} {}
-
-        void write(const TValue* data, size_t size) {
-            //for optimization
-            _ios->rdbuf()->sputn( data , size );
-        }
-
-        void flush() {
-            if (auto ostream = dynamic_cast<std::basic_ostream<TChar, CharTraits>*>(_ios))
-                ostream->flush();
-        }
-
-        size_t writtenBytesCount() const {
-            static_assert(std::is_void<TChar>::value, "`writtenBytesCount` cannot be used with stream adapter");
-            //streaming doesn't return written bytes
-            return 0u;
-        }
-
-        //this method is only for stream writing
-        bool isValidState() const {
-            return !_ios->bad();
-        }
-
-    private:
-        std::basic_ios<TChar, CharTraits>* _ios;
-    };
-
-    template <typename TChar, typename CharTraits, typename TBuffer = std::array<TChar, 256>>
-    class BasicBufferedOutputStreamAdapter {
-    public:
-        using Buffer = TBuffer;
-        using BufferIt = typename traits::BufferAdapterTraits<TBuffer>::TIterator;
-        static_assert(details::IsDefined<BufferIt>::value, "Please define BufferAdapterTraits or include from <bitsery/traits/...> to use as buffer for BasicBufferedOutputStreamAdapter");
-        static_assert(traits::ContainerTraits<Buffer>::isContiguous, "BasicBufferedOutputStreamAdapter only works with contiguous containers");
-        using TValue = TChar;
-        using TIterator = void;//TIterator is used with sessions, but streams cannot be used with sessions
-
-        //bufferSize is used when buffer is dynamically allocated
-        BasicBufferedOutputStreamAdapter(std::basic_ios<TChar, CharTraits>& ostream, size_t bufferSize = 256)
-                :_adapter(ostream),
-                 _buf{},
-                 _outIt{}
-        {
-            init(bufferSize, TResizable{});
-        }
-
-        //we need to explicitly declare move logic, in case buffer is static, because after move it will be invalidated
-        BasicBufferedOutputStreamAdapter(const BasicBufferedOutputStreamAdapter&) = delete;
-        BasicBufferedOutputStreamAdapter& operator = (const BasicBufferedOutputStreamAdapter&) = delete;
-
-        BasicBufferedOutputStreamAdapter(BasicBufferedOutputStreamAdapter&& rhs)
-                : _adapter{std::move(rhs._adapter)},
-                  _buf{},
-                  _outIt{}
-        {
-            auto size = std::distance(std::begin(rhs._buf), rhs._outIt);
-            _buf = std::move(rhs._buf);
-            _outIt = std::next(std::begin(_buf), size);
-        };
-
-        BasicBufferedOutputStreamAdapter& operator = (BasicBufferedOutputStreamAdapter&& rhs) {
-            _adapter = std::move(rhs._adapter);
-            //get current written size, before move
-            auto size = std::distance(std::begin(rhs._buf), rhs._outIt);
-            _buf = std::move(rhs._buf);
-            _outIt = std::next(std::begin(_buf), size);
-            return *this;
-        };
-
-        ~BasicBufferedOutputStreamAdapter() = default;
-
-        void write(const TValue* data, size_t size) {
-            auto tmp = _outIt;
-
-#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
-            using TDistance = typename std::iterator_traits<BufferIt>::difference_type;
-            if (std::distance(_outIt , std::end(_buf)) >= static_cast<TDistance>(size)) {
-                std::memcpy(std::addressof(*_outIt), data, size);
-                _outIt += size;
-#else
-            _outIt += size;
-            if (std::distance(_outIt , std::end(_buf)) >= 0) {
-                std::memcpy(std::addressof(*tmp), data, size);
-#endif
-            } else {
-                //when buffer is full write out to stream
-                _outIt = std::begin(_buf);
-                _adapter.write(std::addressof(*_outIt), static_cast<size_t>(std::distance(_outIt, tmp)));
-                _adapter.write(data, size);
-            }
-        }
-
-        void flush() {
-            auto begin = std::begin(_buf);
-            _adapter.write(std::addressof(*begin), static_cast<size_t>(std::distance(begin, _outIt)));
-            _outIt = begin;
-            _adapter.flush();
-        }
-
-        size_t writtenBytesCount() const {
-            return _adapter.writtenBytesCount();
-        }
-
-        //this method is only for stream writing
-        bool isValidState() const {
-            return _adapter.isValidState();
-        }
-
-    private:
-        using TResizable = std::integral_constant<bool, traits::ContainerTraits<TBuffer>::isResizable>;
-
-        void init (size_t bufferSize, std::true_type) {
-            _buf.resize(bufferSize);
-            _outIt = std::begin(_buf);
-        }
-        void init (size_t, std::false_type) {
-            _outIt = std::begin(_buf);
-        }
-
-        BasicOutputStreamAdapter<TChar, CharTraits> _adapter;
-        TBuffer _buf;
-        BufferIt _outIt;
-    };
-
-    template <typename TChar, typename CharTraits>
-    class BasicIOStreamAdapter:public BasicInputStreamAdapter<TChar, CharTraits>, public BasicOutputStreamAdapter<TChar, CharTraits> {
-    public:
-        using TValue = TChar;
-        using TIterator = void;//TIterator is used with sessions, but streams cannot be used with sessions
-
-        //both bases contain reference to same iostream, so no need to do anything
-        BasicIOStreamAdapter(std::basic_ios<TChar, CharTraits>& iostream)
-                :BasicInputStreamAdapter<TChar, CharTraits>{iostream},
-                 BasicOutputStreamAdapter<TChar, CharTraits>{iostream} {
-
-        }
-    };
-
-    //helper types for most common implementations for std streams
-    using OutputStreamAdapter = BasicOutputStreamAdapter<char, std::char_traits<char>>;
-    using InputStreamAdapter = BasicInputStreamAdapter<char, std::char_traits<char>>;
-    using IOStreamAdapter = BasicIOStreamAdapter<char, std::char_traits<char>>;
-
-    using OutputBufferedStreamAdapter = BasicBufferedOutputStreamAdapter<char, std::char_traits<char>>;
-}
-
-#endif //BITSERY_ADAPTER_STREAM_H

include/bitsery/adapter_reader.h

@@ -1,272 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-
-#ifndef BITSERY_ADAPTER_READER_H
-#define BITSERY_ADAPTER_READER_H
-
-#include "details/sessions.h"
-#include <algorithm>
-#include <cstring>
-
-
-namespace bitsery {
-
-    template <typename TReader>
-    class AdapterReaderBitPackingWrapper;
-
-    template<typename InputAdapter, typename Config>
-    struct AdapterReader {
-        //this is required by deserializer
-        static constexpr bool BitPackingEnabled = false;
-        using TConfig = Config;
-        using TValue = typename InputAdapter::TValue;
-
-        static_assert(details::IsDefined<TValue>::value, "Please define adapter traits or include from <bitsery/traits/...>");
-
-        using TIterator = typename InputAdapter::TIterator;// used by session reader
-
-        explicit AdapterReader(InputAdapter&& adapter)
-                : _inputAdapter{std::move(adapter)},
-                  _session{*this, _inputAdapter}
-        {
-        }
-
-        AdapterReader(const AdapterReader &) = delete;
-
-        AdapterReader &operator=(const AdapterReader &) = delete;
-
-        //todo add conditional noexcept
-        AdapterReader(AdapterReader &&) = default;
-
-        AdapterReader &operator=(AdapterReader &&) = default;
-
-        ~AdapterReader() noexcept = default;
-
-
-        template<size_t SIZE, typename T>
-        void readBytes(T &v) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            directRead(&v, 1);
-        }
-
-        template<size_t SIZE, typename T>
-        void readBuffer(T *buf, size_t count) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            directRead(buf, count);
-        }
-
-        template<typename T>
-        void readBits(T &, size_t ) {
-            static_assert(std::is_void<T>::value,
-                          "Bit-packing is not enabled.\nEnable by call to `enableBitPacking`) or create Deserializer with bit packing enabled.");
-        }
-
-        void align() {
-        }
-
-        bool isCompletedSuccessfully() const {
-            return _inputAdapter.isCompletedSuccessfully() && !_session.hasActiveSessions();
-        }
-
-        ReaderError error() const {
-            auto err = _inputAdapter.error();
-            if (err == ReaderError::DataOverflow && _session.hasActiveSessions())
-                return ReaderError::NoError;
-            return err;
-        }
-
-        void setError(ReaderError error) {
-            if (this->error() == ReaderError::NoError)
-                _inputAdapter.setError(error);
-        }
-
-        void beginSession() {
-            if (error() == ReaderError::NoError) {
-                _session.begin();
-            }
-        }
-
-        void endSession() {
-            if (error() == ReaderError::NoError) {
-                _session.end();
-            }
-        }
-
-        const InputAdapter& adapter() const {
-            return _inputAdapter;
-        }
-
-    private:
-        friend class AdapterReaderBitPackingWrapper<AdapterReader<InputAdapter, Config>>;
-
-        InputAdapter _inputAdapter;
-        typename std::conditional<Config::BufferSessionsEnabled,
-                session::SessionsReader<AdapterReader<InputAdapter, Config>>,
-                session::DisabledSessionsReader<AdapterReader<InputAdapter, Config>>>::type
-                _session;
-
-        template<typename T>
-        void directRead(T *v, size_t count) {
-            static_assert(!std::is_const<T>::value, "");
-            _inputAdapter.read(reinterpret_cast<TValue *>(v), sizeof(T) * count);
-            //swap each byte if nessesarry
-            _swapDataBits(v, count, std::integral_constant<bool,
-                    Config::NetworkEndianness != details::getSystemEndianness()>{});
-        }
-
-        template<typename T>
-        void _swapDataBits(T *v, size_t count, std::true_type) {
-            std::for_each(v, std::next(v, count), [this](T &x) { x = details::swap(x); });
-        }
-
-        template<typename T>
-        void _swapDataBits(T *, size_t , std::false_type) {
-            //empty function because no swap is required
-        }
-
-    };
-
-    template<typename TReader>
-    class AdapterReaderBitPackingWrapper {
-    public:
-        //this is required by deserializer
-        static constexpr bool BitPackingEnabled = true;
-        using TConfig = typename TReader::TConfig;
-        //make TValue unsigned for bitpacking
-        using UnsignedValue = typename std::make_unsigned<typename TReader::TValue>::type;
-        using ScratchType = typename details::ScratchType<UnsignedValue>::type;
-        static_assert(details::IsDefined<ScratchType>::value, "Underlying adapter value type is not supported");
-
-        explicit AdapterReaderBitPackingWrapper(TReader& reader):_reader{reader}
-        {
-        }
-
-        AdapterReaderBitPackingWrapper(const AdapterReaderBitPackingWrapper&) = delete;
-        AdapterReaderBitPackingWrapper& operator = (const AdapterReaderBitPackingWrapper&) = delete;
-
-        AdapterReaderBitPackingWrapper(AdapterReaderBitPackingWrapper&& ) noexcept = default;
-        AdapterReaderBitPackingWrapper& operator = (AdapterReaderBitPackingWrapper&& ) noexcept = default;
-
-        ~AdapterReaderBitPackingWrapper() {
-            align();
-        }
-
-        template<size_t SIZE, typename T>
-        void readBytes(T &v) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            using UT = typename std::make_unsigned<T>::type;
-            if (!m_scratchBits)
-                _reader.template readBytes<SIZE,T>(v);
-            else
-                readBits(reinterpret_cast<UT &>(v), details::BitsSize<T>::value);
-        }
-
-        template<size_t SIZE, typename T>
-        void readBuffer(T *buf, size_t count) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-
-            if (!m_scratchBits) {
-                _reader.template readBuffer<SIZE,T>(buf, count);
-            } else {
-                using UT = typename std::make_unsigned<T>::type;
-                //todo improve implementation
-                const auto end = buf + count;
-                for (auto it = buf; it != end; ++it)
-                    readBits(reinterpret_cast<UT &>(*it), details::BitsSize<T>::value);
-            }
-        }
-
-
-        template<typename T>
-        void readBits(T &v, size_t bitsCount) {
-            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            readBitsInternal(v, bitsCount);
-        }
-
-        void align() {
-            if (m_scratchBits) {
-                ScratchType tmp{};
-                readBitsInternal(tmp, m_scratchBits);
-                if (tmp)
-                    setError(ReaderError::InvalidData);
-            }
-        }
-
-        bool isCompletedSuccessfully() const {
-            return _reader.isCompletedSuccessfully();
-        }
-
-        ReaderError error() const {
-            return _reader.error();
-        }
-
-        void setError(ReaderError error) {
-            _reader.setError(error);
-        }
-
-        void beginSession() {
-            align();
-            _reader.beginSession();
-        }
-
-        void endSession() {
-            align();
-            _reader.endSession();
-        }
-
-    private:
-        TReader& _reader;
-        ScratchType m_scratch{};
-        size_t m_scratchBits{};
-
-        template<typename T>
-        void readBitsInternal(T &v, size_t size) {
-            auto bitsLeft = size;
-            T res{};
-            while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, details::BitsSize<UnsignedValue>::value);
-                if (m_scratchBits < bits) {
-                    UnsignedValue tmp;
-                    _reader.template readBytes<sizeof(UnsignedValue), UnsignedValue>(tmp);
-                    m_scratch |= static_cast<ScratchType>(tmp) << m_scratchBits;
-                    m_scratchBits += details::BitsSize<UnsignedValue>::value;
-                }
-                auto shiftedRes =
-                        static_cast<T>(m_scratch & ((static_cast<ScratchType>(1) << bits) - 1)) << (size - bitsLeft);
-                res |= shiftedRes;
-                m_scratch >>= bits;
-                m_scratchBits -= bits;
-                bitsLeft -= bits;
-            }
-            v = res;
-        }
-
-    };
-}
-
-#endif //BITSERY_ADAPTER_READER_H

include/bitsery/adapter_writer.h

@@ -1,343 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-
-#ifndef BITSERY_ADAPTER_WRITER_H
-#define BITSERY_ADAPTER_WRITER_H
-
-#include "details/sessions.h"
-
-#include <cassert>
-#include <utility>
-
-
-namespace bitsery {
-
-    template <typename Config>
-    struct BasicMeasureSize {
-        //measure class is bit-packing enabled, no need to create wrapper for it
-        static constexpr bool BitPackingEnabled = true;
-
-        using TConfig = Config;
-        template<size_t SIZE, typename T>
-        void writeBytes(const T &) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            _bitsCount += details::BitsSize<T>::value;
-        }
-
-        template<typename T>
-        void writeBits(const T &, size_t bitsCount) {
-            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            assert(bitsCount <= details::BitsSize<T>::value);
-            _bitsCount += bitsCount;
-        }
-
-        template<size_t SIZE, typename T>
-        void writeBuffer(const T *, size_t count) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            _bitsCount += details::BitsSize<T>::value * count;
-        }
-
-        void align() {
-            auto _scratch = (_bitsCount % 8);
-            _bitsCount += (8 - _scratch) % 8;
-        }
-
-        void flush() {
-            align();
-            //flush sessions count
-            if (_sessionsBytesCount > 0) {
-                _bitsCount += (_sessionsBytesCount + 4) * 8;
-                _sessionsBytesCount = 0;
-            }
-        }
-
-        void beginSession() {
-
-        }
-
-        void endSession() {
-            auto endPos = writtenBytesCount();
-            details::writeSize(*this, endPos);
-            auto sessionEndBytesCount = writtenBytesCount() - endPos;
-            //remove written bytes, because we'll write them at the end
-            _bitsCount -= sessionEndBytesCount * 8;
-            _sessionsBytesCount += sessionEndBytesCount;
-        }
-
-        //get size in bytes
-        size_t writtenBytesCount() const {
-            return _bitsCount / 8;
-        }
-
-    private:
-        size_t _bitsCount{};
-        size_t _sessionsBytesCount{};
-    };
-
-    //helper type for default config
-    using MeasureSize = BasicMeasureSize<DefaultConfig>;
-
-
-    template <typename TWriter>
-    class AdapterWriterBitPackingWrapper;
-
-    template<typename OutputAdapter, typename Config>
-    struct AdapterWriter {
-        //this is required by serializer
-        static constexpr bool BitPackingEnabled = false;
-        using TConfig = Config;
-        using TValue = typename OutputAdapter::TValue;
-
-        static_assert(details::IsDefined<TValue>::value, "Please define adapter traits or include from <bitsery/traits/...>");
-
-        explicit AdapterWriter(OutputAdapter&& adapter)
-                : _outputAdapter{std::move(adapter)}
-        {
-        }
-
-        AdapterWriter(const AdapterWriter &) = delete;
-
-        AdapterWriter &operator=(const AdapterWriter &) = delete;
-
-        //todo add conditional noexcept
-        AdapterWriter(AdapterWriter &&) = default;
-
-        AdapterWriter &operator=(AdapterWriter &&) = default;
-
-        ~AdapterWriter() {
-            flush();
-        }
-
-        template<size_t SIZE, typename T>
-        void writeBytes(const T &v) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            directWrite(&v, 1);
-
-        }
-
-        template<size_t SIZE, typename T>
-        void writeBuffer(const T *buf, size_t count) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            directWrite(buf, count);
-        }
-
-        template<typename T>
-        void writeBits(const T &, size_t ) {
-            static_assert(std::is_void<T>::value,
-                          "Bit-packing is not enabled.\nEnable by call to `enableBitPacking`) or create Serializer with bit packing enabled.");
-        }
-
-        //to have the same interface as bitpackingwriter
-        void align() {
-
-        }
-
-        void flush() {
-            _session.flushSessions(*this);
-            _outputAdapter.flush();
-        }
-
-        size_t writtenBytesCount() const {
-            return _outputAdapter.writtenBytesCount();
-        }
-
-        void beginSession() {
-            _session.begin(*this);
-        }
-
-        void endSession() {
-            _session.end(*this);
-        }
-
-        const OutputAdapter& adapter() const {
-            return _outputAdapter;
-        }
-
-    private:
-        friend class AdapterWriterBitPackingWrapper<AdapterWriter<OutputAdapter, Config>>;
-        template<typename T>
-        void directWrite(T &&v, size_t count) {
-            _directWriteSwapTag(std::forward<T>(v), count, std::integral_constant<bool,
-                    Config::NetworkEndianness != details::getSystemEndianness()>{});
-        }
-
-        template<typename T>
-        void _directWriteSwapTag(const T *v, size_t count, std::true_type) {
-            std::for_each(v, std::next(v, count), [this](const T &v) {
-                const auto res = details::swap(v);
-                _outputAdapter.write(reinterpret_cast<const TValue *>(&res), sizeof(T));
-            });
-        }
-
-        template<typename T>
-        void _directWriteSwapTag(const T *v, size_t count, std::false_type) {
-            _outputAdapter.write(reinterpret_cast<const TValue *>(v), count * sizeof(T));
-        }
-
-        OutputAdapter _outputAdapter;
-        typename std::conditional<Config::BufferSessionsEnabled,
-                session::SessionsWriter<AdapterWriter<OutputAdapter, Config >>,
-                session::DisabledSessionsWriter<AdapterWriter<OutputAdapter, Config>>>::type
-                _session{};
-    };
-
-    //this class is used as wrapper for real AdapterWriter, it doesn't store writer itself just a reference
-    template<typename TWriter>
-    class AdapterWriterBitPackingWrapper {
-    public:
-        //this is required by serializer
-        static constexpr bool BitPackingEnabled = true;
-        using TConfig = typename TWriter::TConfig;
-
-        //make TValue unsigned for bit packing
-        using UnsignedType = typename std::make_unsigned<typename TWriter::TValue>::type;
-        using ScratchType = typename details::ScratchType<UnsignedType>::type;
-        static_assert(details::IsDefined<ScratchType>::value, "Underlying adapter value type is not supported");
-
-        explicit AdapterWriterBitPackingWrapper(TWriter &writer)
-                : _writer{writer}
-        {
-        }
-
-        AdapterWriterBitPackingWrapper(const AdapterWriterBitPackingWrapper&) = delete;
-        AdapterWriterBitPackingWrapper& operator = (const AdapterWriterBitPackingWrapper&) = delete;
-
-        AdapterWriterBitPackingWrapper(AdapterWriterBitPackingWrapper&& ) noexcept = default;
-        AdapterWriterBitPackingWrapper& operator = (AdapterWriterBitPackingWrapper&& ) noexcept = default;
-
-        ~AdapterWriterBitPackingWrapper() {
-            align();
-        }
-
-        template<size_t SIZE, typename T>
-        void writeBytes(const T &v) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-
-            if (!_scratchBits) {
-                _writer.template writeBytes<SIZE,T>(v);
-            } else {
-                using UT = typename std::make_unsigned<T>::type;
-                writeBitsInternal(reinterpret_cast<const UT &>(v), details::BitsSize<T>::value);
-            }
-        }
-
-        template<size_t SIZE, typename T>
-        void writeBuffer(const T *buf, size_t count) {
-            static_assert(std::is_integral<T>(), "");
-            static_assert(sizeof(T) == SIZE, "");
-            if (!_scratchBits) {
-                _writer.template writeBuffer<SIZE,T>(buf, count);
-            } else {
-                using UT = typename std::make_unsigned<T>::type;
-                //todo improve implementation
-                const auto end = buf + count;
-                for (auto it = buf; it != end; ++it)
-                    writeBitsInternal(reinterpret_cast<const UT &>(*it), details::BitsSize<T>::value);
-            }
-        }
-
-        template<typename T>
-        void writeBits(const T &v, size_t bitsCount) {
-            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            assert(0 < bitsCount && bitsCount <= details::BitsSize<T>::value);
-            assert(v <= (bitsCount < 64
-                         ? (1ULL << bitsCount) - 1
-                         : (1ULL << (bitsCount-1)) + ((1ULL << (bitsCount-1)) -1)));
-            writeBitsInternal(v, bitsCount);
-        }
-
-        void align() {
-            writeBitsInternal(UnsignedType{}, (details::BitsSize<UnsignedType>::value - _scratchBits) % 8);
-        }
-
-        void flush() {
-            align();
-            _writer._session.flushSessions(_writer);
-        }
-
-        size_t writtenBytesCount() const {
-            return _writer.writtenBytesCount();
-        }
-
-        void beginSession() {
-            align();
-            _writer._session.begin(_writer);
-        }
-
-        void endSession() {
-            align();
-            _writer._session.end(_writer);
-        }
-
-    private:
-
-        template<typename T>
-        void writeBitsInternal(const T &v, size_t size) {
-            constexpr size_t valueSize = details::BitsSize<UnsignedType>::value;
-            auto value = v;
-            auto bitsLeft = size;
-            while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, valueSize);
-                _scratch |= static_cast<ScratchType>( value ) << _scratchBits;
-                _scratchBits += bits;
-                if (_scratchBits >= valueSize) {
-                    auto tmp = static_cast<UnsignedType>(_scratch & _MASK);
-                    _writer.template writeBytes<sizeof(UnsignedType), UnsignedType >(tmp);
-                    _scratch >>= valueSize;
-                    _scratchBits -= valueSize;
-
-                    value >>= valueSize;
-                }
-                bitsLeft -= bits;
-            }
-        }
-
-        //overload for TValue, for better performance
-        void writeBitsInternal(const UnsignedType &v, size_t size) {
-            if (size > 0) {
-                _scratch |= static_cast<ScratchType>( v ) << _scratchBits;
-                _scratchBits += size;
-                if (_scratchBits >= details::BitsSize<UnsignedType>::value) {
-                    auto tmp = static_cast<UnsignedType>(_scratch & _MASK);
-                    _writer.template writeBytes<sizeof(UnsignedType), UnsignedType>(tmp);
-                    _scratch >>= details::BitsSize<UnsignedType>::value;
-                    _scratchBits -= details::BitsSize<UnsignedType>::value;
-                }
-            }
-        }
-
-        const UnsignedType _MASK = std::numeric_limits<UnsignedType>::max();
-        ScratchType _scratch{};
-        size_t _scratchBits{};
-        TWriter& _writer;
-
-    };
-}
-
-#endif //BITSERY_ADAPTER_WRITER_H

include/bitsery/bitsery.h

@@ -24,8 +24,8 @@
 #ifndef BITSERY_BITSERY_H
 #define BITSERY_BITSERY_H
 
-#define BITSERY_MAJOR_VERSION 4
-#define BITSERY_MINOR_VERSION 2
+#define BITSERY_MAJOR_VERSION 1
+#define BITSERY_MINOR_VERSION 1
 #define BITSERY_PATCH_VERSION 1
 
 #define BITSERY_QUOTE_MACRO(name) #name
@@ -37,6 +37,9 @@ BITSERY_QUOTE_MACRO(patch)
 #define BITSERY_VERSION \
 BITSERY_BUILD_VERSION_STR(BITSERY_MAJOR_VERSION, BITSERY_MINOR_VERSION, BITSERY_PATCH_VERSION)
 
+
+#include "buffer_writer.h"
+#include "buffer_reader.h"
 #include "serializer.h"
 #include "deserializer.h"
 

include/bitsery/buffer_reader.h

@@ -0,0 +1,178 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+
+#ifndef BITSERY_BUFFER_READER_H
+#define BITSERY_BUFFER_READER_H
+
+#include "common.h"
+
+#include <cassert>
+#include <algorithm>
+
+namespace bitsery {
+
+    template <typename Config>
+    struct BasicBufferReader {
+        using ValueType = typename Config::BufferValueType;
+        using ScratchType = typename Config::BufferScrathType;
+
+        BasicBufferReader(const ValueType* data, size_t size) : _pos{data}, _end{data + size}
+        {
+            static_assert(std::is_unsigned<ValueType>(), "Config::BufferValueType must be unsigned");
+            static_assert(std::is_unsigned<ScratchType>(), "Config::BufferScrathType must be unsigned");
+            static_assert(sizeof(ValueType)*2 == sizeof(ScratchType), "ScratchType must be 2x bigger than value type");
+            static_assert(sizeof(ValueType) == 1, "currently only supported BufferValueType is 1 byte");
+        }
+
+        explicit BasicBufferReader(const std::vector<ValueType> &buf) : BasicBufferReader(buf.data(), buf.size()) {
+        }
+
+        template <size_t N>
+        explicit BasicBufferReader(const ValueType (&data)[N]): BasicBufferReader(data, N)
+        {
+        }
+
+        BasicBufferReader(const BasicBufferReader&) = delete;
+        BasicBufferReader& operator=(const BasicBufferReader& ) = delete;
+        BasicBufferReader(BasicBufferReader&&) noexcept = default;
+        BasicBufferReader& operator=(BasicBufferReader&&) noexcept = default;
+        ~BasicBufferReader() noexcept = default;
+
+
+        template<size_t SIZE, typename T>
+        bool readBytes(T &v) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            using UT = typename std::make_unsigned<T>::type;
+            return !m_scratch
+                   ? directRead(&v, 1)
+                   : readBits(reinterpret_cast<UT &>(v), details::BITS_SIZE<T>);
+        }
+
+        template<size_t SIZE, typename T>
+        bool readBuffer(T *buf, size_t count) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+
+            if (!m_scratchBits)
+                return directRead(buf, count);
+
+            using UT = typename std::make_unsigned<T>::type;
+            //todo improve implementation
+            const auto end = buf + count;
+            for (auto it = buf; it != end; ++it) {
+                if (!readBits(reinterpret_cast<UT &>(*it), details::BITS_SIZE<T>))
+                    return false;
+            }
+            return true;
+        }
+
+
+        template<typename T>
+        bool readBits(T &v, size_t bitsCount) {
+            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
+            assert(bitsCount <= details::BITS_SIZE<T>);
+
+            const auto bytesRequired = bitsCount > m_scratchBits
+                                       ? ((bitsCount - 1 - m_scratchBits) >> 3) + 1u
+                                       : 0u;
+            if (static_cast<size_t>(std::distance(_pos, _end)) < bytesRequired)
+                return false;
+            readBitsInternal(v, bitsCount);
+            return true;
+        }
+
+        bool align() {
+            if (m_scratchBits) {
+                ScratchType tmp{};
+                readBitsInternal(tmp, m_scratchBits);
+                return tmp == 0;
+            }
+            return true;
+        }
+
+        bool isCompleted() const {
+            return _pos == _end;
+        }
+
+    private:
+        const ValueType* _pos;
+        const ValueType* _end;
+
+        template<typename T>
+        bool directRead(T *v, size_t count) {
+            static_assert(!std::is_const<T>::value, "");
+            const auto bytesCount = sizeof(T) * count;
+            if (static_cast<size_t>(std::distance(_pos, _end)) < bytesCount)
+                return false;
+            //read from buffer, to data ptr,
+            std::copy_n(_pos, bytesCount, reinterpret_cast<ValueType *>(v));
+            std::advance(_pos, bytesCount);
+            //swap each byte if nessesarry
+            _swapDataBits(v, count, std::integral_constant<bool,
+                    Config::NetworkEndianness != details::getSystemEndianness()>{});
+            return true;
+        }
+
+        template<typename T>
+        void _swapDataBits(T *v, size_t count, std::true_type) {
+            std::for_each(v, std::next(v, count), [this](T& v) { v = details::swap(v); });
+        }
+
+        template<typename T>
+        void _swapDataBits(T *v, size_t count, std::false_type) {
+            //empty function because no swap is required
+        }
+
+        template<typename T>
+        void readBitsInternal(T &v, size_t size) {
+            auto bitsLeft = size;
+            T res{};
+            while (bitsLeft > 0) {
+                auto bits = std::min(bitsLeft, details::BITS_SIZE<ValueType>);
+                if (m_scratchBits < bits) {
+                    ValueType tmp;
+                    directRead(&tmp, 1);
+                    m_scratch |= static_cast<ScratchType>(tmp) << m_scratchBits;
+                    m_scratchBits += details::BITS_SIZE<ValueType>;
+                }
+                auto shiftedRes =
+                        static_cast<T>(m_scratch & ((static_cast<ScratchType>(1) << bits) - 1)) << (size - bitsLeft);
+                res |= shiftedRes;
+                m_scratch >>= bits;
+                m_scratchBits -= bits;
+                bitsLeft -= bits;
+            }
+            v = res;
+        }
+
+        ScratchType m_scratch{};
+        size_t m_scratchBits{};                                    ///< Number of bits currently in the scratch buffer. If the user wants to read more bits than this, we have to go fetch another dword from memory.
+
+    };
+    //helper type
+    using BufferReader = BasicBufferReader<DefaultConfig>;
+}
+
+#endif //BITSERY_BUFFER_READER_H

include/bitsery/buffer_writer.h

@@ -0,0 +1,205 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+
+#ifndef BITSERY_BUFFER_WRITER_H
+#define BITSERY_BUFFER_WRITER_H
+
+#include "common.h"
+#include <cassert>
+#include <algorithm>
+#include <iterator>
+#include <utility>
+
+namespace bitsery {
+
+    struct MeasureSize {
+
+        template<size_t SIZE, typename T>
+        void writeBytes(const T &) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            _bitsCount += details::BITS_SIZE<T>;
+        }
+
+        template<typename T>
+        void writeBits(const T &, size_t bitsCount) {
+            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
+            assert(bitsCount <= details::BITS_SIZE<T>);
+            _bitsCount += bitsCount;
+        }
+
+        template<size_t SIZE, typename T>
+        void writeBuffer(const T *, size_t count) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            _bitsCount += details::BITS_SIZE<T> * count;
+        }
+
+        //get size in bytes
+        size_t getSize() const {
+            return _bitsCount / 8;
+        }
+
+    private:
+        size_t _bitsCount{};
+
+    };
+
+    template <typename Config>
+    struct BasicBufferWriter {
+        using ValueType = typename Config::BufferValueType;
+        using ScratchType = typename Config::BufferScrathType;
+
+        explicit BasicBufferWriter(std::vector<ValueType> &buffer) : _outIt{std::back_inserter(buffer)} {
+            static_assert(std::is_unsigned<ValueType>(), "Config::BufferValueType must be unsigned");
+            static_assert(std::is_unsigned<ScratchType>(), "Config::BufferScrathType must be unsigned");
+            static_assert(sizeof(ValueType)*2 == sizeof(ScratchType), "ScratchType must be 2x bigger than value type");
+            static_assert(sizeof(ValueType) == 1, "currently only supported BufferValueType is 1 byte");
+        }
+
+        BasicBufferWriter(const BasicBufferWriter&) = delete;
+        BasicBufferWriter& operator=(const BasicBufferWriter& ) = delete;
+        BasicBufferWriter(BasicBufferWriter&&) noexcept = default;
+        BasicBufferWriter& operator=(BasicBufferWriter&&) noexcept = default;
+        ~BasicBufferWriter() noexcept = default;
+
+        template<size_t SIZE, typename T>
+        void writeBytes(const T &v) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+
+            if (!_scratchBits) {
+                directWrite(&v, 1);
+            } else {
+                using UT = typename std::make_unsigned<T>::type;
+                writeBits(reinterpret_cast<const UT &>(v), details::BITS_SIZE<T>);
+            }
+        }
+
+        template<size_t SIZE, typename T>
+        void writeBuffer(const T *buf, size_t count) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            if (!_scratchBits) {
+                directWrite(buf, count);
+            } else {
+                using UT = typename std::make_unsigned<T>::type;
+                //todo improve implementation
+                const auto end = buf + count;
+                for (auto it = buf; it != end; ++it)
+                    writeBits(reinterpret_cast<const UT &>(*it), details::BITS_SIZE<T>);
+            }
+        }
+
+        template<typename T>
+        void writeBits(const T &v, size_t bitsCount) {
+            static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
+            assert(0 < bitsCount && bitsCount <= details::BITS_SIZE<T>);
+            assert(v <= ((1ULL << bitsCount) - 1));
+            writeBitsInternal(v, bitsCount);
+        }
+
+        void align() {
+            if (_scratchBits)
+                writeBitsInternal(ValueType{}, details::BITS_SIZE<ValueType> - _scratchBits);
+        }
+
+        void flush() {
+            if (_scratchBits) {
+                auto tmp = static_cast<ValueType>( _scratch & _MASK );
+                directWrite(&tmp, 1);
+                _scratch >>= _scratchBits;
+                _scratchBits -= _scratchBits;
+            }
+        }
+
+
+    private:
+
+        template<typename T>
+        void directWrite(T&& v, size_t count) {
+            _directWriteSwapTag(std::forward<T>(v), count, std::integral_constant<bool,
+                    Config::NetworkEndianness != details::getSystemEndianness()>{});
+        }
+
+        template<typename T>
+        void _directWriteSwapTag(const T *v, size_t count, std::true_type) {
+            std::for_each(v, std::next(v, count), [this](const T& v) {
+                const auto res = details::swap(v);
+                std::copy_n(reinterpret_cast<const ValueType*>(&res), sizeof(T), _outIt);
+            });
+        }
+
+        template<typename T>
+        void _directWriteSwapTag(const T *v, size_t count, std::false_type) {
+            std::copy_n(reinterpret_cast<const ValueType*>(v), count * sizeof(T), _outIt);
+        }
+
+        template<typename T>
+        void writeBitsInternal(const T &v, size_t size) {
+            constexpr size_t valueSize = details::BITS_SIZE<ValueType>;
+            auto value = v;
+            auto bitsLeft = size;
+            while (bitsLeft > 0) {
+                auto bits = std::min(bitsLeft, valueSize);
+                _scratch |= static_cast<ScratchType>( value ) << _scratchBits;
+                _scratchBits += bits;
+                if (_scratchBits >= valueSize) {
+                    auto tmp = static_cast<ValueType>(_scratch & _MASK);
+                    directWrite(&tmp, 1);
+                    _scratch >>= valueSize;
+                    _scratchBits -= valueSize;
+
+                    value >>= valueSize;
+                }
+                bitsLeft -= bits;
+            }
+        }
+
+        //overload for ValueType, for better performance
+        void writeBitsInternal(const ValueType &v, size_t size) {
+            if (size > 0) {
+                _scratch |= static_cast<ScratchType>( v ) << _scratchBits;
+                _scratchBits += size;
+                if (_scratchBits >= details::BITS_SIZE<ValueType>) {
+                    auto tmp = static_cast<ValueType>(_scratch & _MASK);
+                    directWrite(&tmp, 1);
+                    _scratch >>= details::BITS_SIZE<ValueType>;
+                    _scratchBits -= details::BITS_SIZE<ValueType>;
+                }
+            }
+        }
+
+
+        const ValueType _MASK = std::numeric_limits<ValueType>::max();
+        std::back_insert_iterator<std::vector<ValueType>> _outIt;
+        ScratchType _scratch{};
+        size_t _scratchBits{};
+    };
+
+    //helper type
+    using BufferWriter = BasicBufferWriter<DefaultConfig>;
+}
+
+#endif //BITSERY_BUFFER_WRITER_H

include/bitsery/common.h

@@ -24,31 +24,24 @@
 #ifndef BITSERY_COMMON_H
 #define BITSERY_COMMON_H
 
-#include <tuple>
+#include "bitsery/details/buffer_common.h"
 
 namespace bitsery {
 
-/*
- * endianess
- */
-    enum class EndiannessType {
-        LittleEndian,
-        BigEndian
+    struct DefaultConfig {
+        static constexpr EndiannessType NetworkEndianness = EndiannessType::LittleEndian;
+        using BufferValueType = uint8_t;
+        using BufferScrathType = uint16_t;
     };
 
-    //default configuration for buffer writing/reading operations
-    struct DefaultConfig {
-        //data will be stored in little endian, independant of host.
-        static constexpr EndiannessType NetworkEndianness = EndiannessType::LittleEndian;
-        //this functionality allows to support backward/forward compatibility
-        //however reading from streams is not supported, because this functionality requires random access to buffer.
-        static constexpr bool BufferSessionsEnabled = false;
-        //list of contexts that will be instanciated internally within serializer/deserializer.
-        //contexts must be default constructable.
-        //internal context has priority, if external context with the same type exists.
-        using InternalContext = std::tuple<>;
-    };
+/*
+ * serializer macro, serialize function specialization that accepts T& and const T&
+ */
+
+
+#define SERIALIZE(ObjectType) \
+template <typename S, typename T, typename std::enable_if<std::is_same<T, ObjectType>::value || std::is_same<T, const ObjectType>::value>::type* = nullptr> \
+S& serialize(S& s, T& o)
 
 }
-
 #endif //BITSERY_COMMON_H

include/bitsery/delta_deserializer.h

@@ -0,0 +1,220 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+
+#ifndef BITSERY_DELTADESERIALIZER_H
+#define BITSERY_DELTADESERIALIZER_H
+
+#include <array>
+#include <stack>
+#include <algorithm>
+#include "deserializer.h"
+
+namespace bitsery {
+
+    template<typename Reader, typename TObj>
+    class DeltaDeserializer {
+    public:
+        DeltaDeserializer(Reader &r, const TObj &oldObj, const TObj &newObj)
+                : _deserializer{r},
+                  _reader{r},
+                  _oldObj{oldObj},
+                  _newObj{newObj},
+                  _objMemPos(std::deque<details::ObjectMemoryPosition>(1, details::ObjectMemoryPosition{oldObj, newObj})),
+                  _isNewElement{false} {
+        };
+
+        template<size_t SIZE = 0, typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        DeltaDeserializer &value(T &v) {
+            if (getChangedState(v)) {
+                constexpr size_t ValueSize = SIZE == 0 ? sizeof(T) : SIZE;
+                _reader.template readBytes<ValueSize>(v);
+            }
+            return *this;
+        }
+
+        template<typename T>
+        DeltaDeserializer &object(T &&obj) {
+            if (getChangedState(obj))
+                return serialize(*this, std::forward<T>(obj));
+            return *this;
+        }
+
+        template<size_t VSIZE = 1, typename T>
+        DeltaDeserializer &text(std::basic_string<T> &str, size_t maxSize) {
+            if (getChangedState(str)) {
+                _deserializer.template text<VSIZE>(str, maxSize);
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE = 1, typename T, size_t N>
+        DeltaDeserializer &text(T (&str)[N]) {
+            if (getChangedState(str)) {
+                _deserializer.template text<VSIZE>(str);
+            }
+            return *this;
+        }
+
+
+        template<typename T, size_t N, typename Fnc>
+        DeltaDeserializer &array(std::array<T, N> &arr, Fnc &&fnc) {
+            if (getChangedState(arr)) {
+                if (!_isNewElement) {
+                    const auto old = *_objMemPos.top().getOldObjectField(arr);
+                    processContainer(std::begin(old), std::end(old), std::begin(arr), std::end(arr), fnc);
+                } else {
+                    for (auto &v:arr)
+                        fnc(*this, v);
+                }
+            }
+            return *this;
+        }
+
+
+        template<typename T, size_t N, typename Fnc>
+        DeltaDeserializer &array(T (&arr)[N], Fnc &&fnc) {
+            if (getChangedState(arr)) {
+                if (!_isNewElement) {
+                    const auto old = *_objMemPos.top().getOldObjectField(arr);
+                    T *tmp = arr;
+                    processContainer(old, old + N, tmp, tmp + N, fnc);
+                } else {
+                    T *tmp = arr;
+                    for (auto i = 0u; i < N; ++i, ++tmp)
+                        fnc(*this, *tmp);
+                }
+            }
+            return *this;
+        }
+
+        template<typename T, typename Fnc>
+        DeltaDeserializer &container(T &obj, size_t maxSize, Fnc &&fnc) {
+            if (getChangedState(obj)) {
+                size_t newSize{};
+                _reader.readBits(newSize, 32);
+                if (!_isNewElement) {
+                    auto old = *_objMemPos.top().getOldObjectField(obj);
+                    if (old.size() != newSize)
+                        obj.resize(newSize);
+                    processContainer(std::begin(old), std::end(old), std::begin(obj), std::end(obj),
+                                     std::forward<Fnc>(fnc));
+                } else {
+                    obj.resize(newSize);
+                    for (auto &v:obj)
+                        fnc(*this, v);
+                }
+            }
+            return *this;
+        }
+
+    private:
+        Deserializer <Reader> _deserializer;
+        Reader &_reader;
+
+        const TObj &_oldObj;
+        const TObj &_newObj;
+        std::stack<details::ObjectMemoryPosition> _objMemPos;
+        bool _isNewElement;
+
+        template<typename T>
+        bool getChangedState(T &obj) {
+            if (!_isNewElement) {
+                if (!readChangedState()) {
+                    obj = *_objMemPos.top().getOldObjectField(obj);
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        template<typename T, size_t N>
+        bool getChangedState(T (&arr)[N]) {
+            if (!_isNewElement) {
+                if (!readChangedState()) {
+                    auto old = *_objMemPos.top().getOldObjectField(arr);
+                    auto end = arr + N;
+                    auto pOld = old;
+                    for (auto p = arr; p != end; ++p, ++pOld)
+                        *p = *pOld;
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        template<typename TConstIt, typename TIt, typename Fnc>
+        bool processContainer(TConstIt oldBegin, TConstIt oldEnd, TIt begin, TIt end, Fnc &&fnc) {
+            auto offset = readIndexOffset();
+            auto p = begin;
+            auto pOld = oldBegin;
+            for (; p != end && pOld != oldEnd; ++p, ++pOld) {
+                if (offset) {
+                    *p = *pOld;
+                    --offset;
+                } else {
+                    _objMemPos.emplace(details::ObjectMemoryPosition{*pOld, *p});
+                    fnc(*this, *p);
+                    _objMemPos.pop();
+                    offset = readIndexOffset();
+                }
+            }
+            if (offset != 0 && pOld != oldEnd)
+                return false;
+            _isNewElement = true;
+            for (; p != end; ++p, --offset)
+                fnc(*this, *p);
+            _isNewElement = false;
+            return offset == 0;
+
+        }
+
+        bool readChangedState() {
+            unsigned char res{};
+            _reader.readBits(res, 1);
+            return res;
+        }
+
+
+        size_t readIndexOffset() {
+            //special case, if items are updated sequentialy
+            unsigned char tmp{};
+            _reader.readBits(tmp, 1);
+            if (tmp) {
+                return 0u;
+            } else {
+                size_t res{};
+                _reader.readBits(tmp, 1);
+                if (tmp > 0)
+                    _reader.readBits(res, 4);
+                else
+                    _reader.readBits(res, 32);
+                return res;
+            }
+
+        }
+
+    };
+
+}
+#endif //BITSERY_DELTADESERIALIZER_H

include/bitsery/delta_serializer.h

@@ -0,0 +1,220 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+
+#ifndef BITSERY_DELTASERIALIZER_H
+#define BITSERY_DELTASERIALIZER_H
+
+#include <array>
+#include <stack>
+#include <algorithm>
+#include "serializer.h"
+
+namespace bitsery {
+
+    template<typename Writter, typename TObj>
+    class DeltaSerializer {
+    public:
+        DeltaSerializer(Writter &w, const TObj &oldObj, const TObj &newObj)
+                : _serializer{w},
+                  _writter{w},
+                  _oldObj{oldObj},
+                  _newObj{newObj},
+                  _objMemPos(std::deque<details::ObjectMemoryPosition>(1, details::ObjectMemoryPosition{oldObj, newObj})),
+                  _isNewElement{false} {
+
+        };
+
+        template<size_t SIZE = 0, typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        DeltaSerializer &value(const T &v) {
+            if (setChangedState(v)) {
+                constexpr size_t ValueSize = SIZE == 0 ? sizeof(T) : SIZE;
+                _writter.template writeBytes<ValueSize>(v);
+            }
+            return *this;
+        }
+
+        template<typename T>
+        DeltaSerializer &object(T &&obj) {
+            if (setChangedState(obj)) {
+                serialize(*this, std::forward<T>(obj));
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE = 1, typename T>
+        DeltaSerializer &text(const std::basic_string<T> &str, size_t maxSize) {
+            if (setChangedState(str)) {
+                _serializer.template text<VSIZE>(str, maxSize);
+            }
+            return *this;
+
+        }
+
+        template<size_t VSIZE = 1, typename T, size_t N>
+        DeltaSerializer &text(const T (&str)[N]) {
+            if (setChangedState(str)) {
+                _serializer.template text<VSIZE>(str);
+            }
+            return *this;
+
+        }
+
+        template<typename T, size_t N, typename Fnc>
+        DeltaSerializer &array(const std::array<T, N> &arr, Fnc &&fnc) {
+            if (setChangedState(arr)) {
+                if (!_isNewElement) {
+                    const auto &old = *_objMemPos.top().getOldObjectField(arr);
+                    processContainer(std::begin(old), std::end(old), std::begin(arr), std::end(arr), fnc);
+                } else {
+                    for (auto &v:arr)
+                        fnc(*this, v);
+                }
+            }
+            return *this;
+        }
+
+
+        template<typename T, size_t N, typename Fnc>
+        DeltaSerializer &array(const T (&arr)[N], Fnc &&fnc) {
+            if (setChangedState(arr)) {
+                if (!_isNewElement) {
+                    auto old = *_objMemPos.top().getOldObjectField(arr);
+                    const T *tmp = arr;
+                    processContainer(old, old + N, tmp, tmp + N, fnc);
+                } else {
+                    const T *tmp = arr;
+                    for (auto i = 0u; i < N; ++i, ++tmp)
+                        fnc(*this, *tmp);
+                }
+            }
+            return *this;
+        }
+
+        template<typename T, typename Fnc>
+        DeltaSerializer &container(T &&obj, size_t maxSize, Fnc &&fnc) {
+            if (setChangedState(obj)) {
+                _writter.writeBits(obj.size(), 32);
+                if (!_isNewElement) {
+                    auto old = *_objMemPos.top().getOldObjectField(obj);
+                    processContainer(std::begin(old), std::end(old), std::begin(obj), std::end(obj),
+                                     std::forward<Fnc>(fnc));
+                } else {
+                    for (auto &v:obj)
+                        fnc(*this, v);
+                }
+            }
+            return *this;
+        }
+
+    private:
+        Serializer <Writter> _serializer;
+        Writter &_writter;
+        const TObj &_oldObj;
+        const TObj &_newObj;
+        std::stack<details::ObjectMemoryPosition> _objMemPos;
+        bool _isNewElement;
+
+        template<typename T>
+        bool setChangedState(const T &obj) {
+            if (!_isNewElement) {
+                auto res = !_objMemPos.top().isFieldsEquals(obj);
+                writeChangedState(res);
+                return res;
+            }
+            return true;
+        }
+
+        template<typename T, size_t N>
+        bool setChangedState(const T (&arr)[N]) {
+            if (!_isNewElement) {
+                auto old = *_objMemPos.top().getOldObjectField(arr);
+                auto end = arr + N;
+                bool changed{};
+                for (auto p = arr, pOld = old; p != end; ++p, ++pOld) {
+                    if (!(*p == *pOld)) {
+                        changed = true;
+                        break;
+                    }
+                }
+                writeChangedState(changed);
+                return changed;
+            }
+            return true;
+        }
+
+
+        template<typename T, typename Fnc>
+        void processContainer(const T oldBegin, const T oldEnd, const T begin, const T end, Fnc &&fnc) {
+            auto misMatch = std::mismatch(oldBegin, oldEnd, begin, end);
+            auto lastChanged = begin;
+            while (misMatch.first != oldEnd && misMatch.second != end) {
+                writeIndexOffset(std::distance(lastChanged, misMatch.second));
+                _objMemPos.emplace(details::ObjectMemoryPosition{*misMatch.first, *misMatch.second});
+                fnc(*this, *misMatch.second);
+                _objMemPos.pop();
+                ++misMatch.first;
+                ++misMatch.second;
+                lastChanged = misMatch.second;
+                misMatch = std::mismatch(misMatch.first, oldEnd, misMatch.second, end);
+            }
+            auto p = misMatch.second;
+            //write items left
+            writeIndexOffset(std::distance(lastChanged, end));
+            //write old elements
+            for (auto pOld = misMatch.first; p != end && pOld != oldEnd; ++p, ++pOld) {
+                _objMemPos.emplace(details::ObjectMemoryPosition{*pOld, *p});
+                fnc(*this, *p);
+                _objMemPos.pop();
+            }
+
+            //write new elements
+            _isNewElement = true;
+            for (; p != end; ++p)
+                fnc(*this, *p);
+            _isNewElement = false;
+        }
+
+        void writeChangedState(bool state) {
+            _writter.writeBits(state ? 1u : 0u, 1);
+        }
+
+        void writeIndexOffset(const size_t offset) {
+            //special case, if items are updated sequentialy
+            if (offset == 0) {
+                _writter.writeBits(1u, 1);
+            } else {
+                _writter.writeBits(0u, 1);
+                auto smallOffset = offset < 16;
+                _writter.writeBits(smallOffset ? 1u : 0u, 1);
+                if (smallOffset)
+                    _writter.writeBits(offset, 4);
+                else
+                    _writter.writeBits(offset, 32);
+            }
+        }
+
+    };
+
+}
+#endif //BITSERY_DELTASERIALIZER_H

include/bitsery/deserializer.h

@@ -24,419 +24,355 @@
 #ifndef BITSERY_DESERIALIZER_H
 #define BITSERY_DESERIALIZER_H
 
+#include "common.h"
 #include "details/serialization_common.h"
-#include "adapter_reader.h"
 #include <utility>
 
 namespace bitsery {
 
 
-    template<typename TAdapterReader, typename TContext = void>
-    class BasicDeserializer {
+    template<typename Reader>
+    class Deserializer {
     public:
-        //this is used by AdapterAccess class
-        using TReader = TAdapterReader;
-        //helper type, that always returns bit-packing enabled type, useful inside serialize function when enabling bitpacking
-        using BPEnabledType = BasicDeserializer<typename std::conditional<TAdapterReader::BitPackingEnabled,
-                TAdapterReader, AdapterReaderBitPackingWrapper<TAdapterReader>>::type, TContext>;
-
-        static_assert(details::IsSpecializationOf<typename TReader::TConfig::InternalContext, std::tuple>::value,
-                      "Config::InternalContext must be std::tuple");
-
-        template <typename ReaderParam>
-        explicit BasicDeserializer(ReaderParam&& r, TContext* context = nullptr)
-                : _reader{std::forward<ReaderParam>(r)},
-                  _context{context},
-                  _internalContext{}
-        {
-        }
-
-        //copying disabled
-        BasicDeserializer(const BasicDeserializer&) = delete;
-        BasicDeserializer& operator = (const BasicDeserializer&) = delete;
-
-        //move enabled
-        BasicDeserializer(BasicDeserializer&& ) = default;
-        BasicDeserializer& operator = (BasicDeserializer&& ) = default;
-
-        /*
-         * get serialization context.
-         * this is optional, but might be required for some specific deserialization flows.
-         */
-        TContext* context() {
-            return _context;
-        }
+        Deserializer(Reader& r):_reader{r}, _isValid{true} {};
 
         template <typename T>
-        T* context(){
-            return details::getContext<T>(_context, _internalContext);
+        Deserializer& object(T&& obj) {
+            return serialize(*this, std::forward<T>(obj));
         }
 
+        //in c++17 change "class" to typename
+        template <template <typename> class Extension, typename TValue, typename Fnc>
+        Deserializer& ext(TValue& v, Fnc&& fnc) {
+            static_assert(!std::is_const<TValue>(), "");
+            Extension<TValue> ext{v};
+            ext.deserialize(*this, std::forward<Fnc>(fnc));
+            return *this;
+        };
+
+        /*
+         * value overloads
+         */
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            static_assert(std::numeric_limits<T>::is_iec559, "");
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(reinterpret_cast<details::SAME_SIZE_UNSIGNED<T>&>(v));
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            using UT = std::underlying_type_t<T>;
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(reinterpret_cast<UT&>(v));
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(v);
+            }
+            return *this;
+        }
+
+        /*
+         * bool
+         */
+
+        Deserializer& boolBit(bool& v) {
+            if (_isValid) {
+                unsigned char tmp;
+                _isValid = _reader.readBits(tmp, 1);
+                v = tmp == 1;
+            }
+            return *this;
+        }
+
+        Deserializer& boolByte(bool& v) {
+            if (_isValid) {
+                unsigned char tmp;
+                _isValid = _reader.template readBytes<1>(tmp);
+                if (_isValid)
+                    _isValid = tmp < 2;
+                v = tmp == 1;
+            }
+            return *this;
+        }
+
+        /*
+         * range
+         */
+
         template <typename T>
-        T* contextOrNull(){
-            return details::getContextIfTypeExists<T>(_context, _internalContext);
+        Deserializer& range(T& v, const RangeSpec<T>& range) {
+            if (_isValid) {
+                _isValid = _reader.readBits(reinterpret_cast<details::SAME_SIZE_UNSIGNED<T>&>(v), range.bitsRequired);
+                details::setRangeValue(v, range);
+                if (_isValid)
+                    _isValid = details::isRangeValid(v, range);
+            }
+            return *this;
         }
 
         /*
-         * object function
+         * substitution overloads
          */
+        template<typename T, size_t N, typename Fnc>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues, Fnc&& fnc) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    fnc(*this, v);
+            }
+            return *this;
+        };
 
-        template<typename T>
-        void object(T &&obj) {
-            details::SerializeFunction<BasicDeserializer, T>::invoke(*this, std::forward<T>(obj));
-        }
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    value<VSIZE>(v);
+            }
+            return *this;
+        };
 
-        template<typename T, typename Fnc>
-        void object(T &&obj, Fnc &&fnc) {
-            fnc(std::forward<T>(obj));
-        }
-
-        /*
-         * functionality, that enables simpler serialization syntax, by including additional header
-         */
-        template<typename T, typename ... TArgs>
-        void archive(T &&head, TArgs &&... tail) {
-            //serialize object
-            details::ArchiveFunction<BasicDeserializer, T>::invoke(*this, std::forward<T>(head));
-            //expand other elements
-            archive(std::forward<TArgs>(tail)...);
-        }
-
-        /*
-         * value
-         */
-
-        template<size_t VSIZE, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
-        void value(T &v) {
-            using TValue = typename details::IntegralFromFundamental<T>::TValue;
-            _reader.template readBytes<VSIZE>(reinterpret_cast<TValue &>(v));
-        }
-
-        /*
-         * enable bit-packing
-         */
-        template <typename Fnc>
-        void enableBitPacking(Fnc&& fnc) {
-            procEnableBitPacking(std::forward<Fnc>(fnc), std::integral_constant<bool, TAdapterReader::BitPackingEnabled>{});
-        }
-
-        /*
-         * extension functions
-         */
-
-        template<typename T, typename Ext, typename Fnc>
-        void ext(T &obj, const Ext &extension, Fnc &&fnc) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
-                          "extension doesn't support overload with lambda");
-            extension.deserialize(*this, _reader, obj, std::forward<Fnc>(fnc));
-        }
-
-        template<size_t VSIZE, typename T, typename Ext>
-        void ext(T &obj, const Ext &extension) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportValueOverload,
-                          "extension doesn't support overload with `value<N>`");
-            using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
-            using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.deserialize(*this, _reader, obj, [this](VType &v) { value<VSIZE>(v);});
-        }
-
-        template<typename T, typename Ext>
-        void ext(T &obj, const Ext &extension) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportObjectOverload,
-                          "extension doesn't support overload with `object`");
-            using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
-            using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.deserialize(*this, _reader, obj, [this](VType &v) { object(v); });
-        }
-
-        /*
-         * boolValue
-         */
-        void boolValue(bool &v) {
-            procBoolValue(v, std::integral_constant<bool, TAdapterReader::BitPackingEnabled>{});
-        }
+        template<typename T, size_t N>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    object(v);
+            }
+            return *this;
+        };
 
         /*
          * text overloads
          */
 
-        template<size_t VSIZE, typename T>
-        void text(T &str, size_t maxSize) {
-            static_assert(details::IsTextTraitsDefined<T>::value,
-                          "Please define TextTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use text(T&) overload without `maxSize` for static containers");
-            size_t length;
-            details::readSize(_reader, length, maxSize);
-            traits::ContainerTraits<T>::resize(str, length + (traits::TextTraits<T>::addNUL ? 1u : 0u));
-            procText<VSIZE>(str, length);
+        template <size_t VSIZE, typename T>
+        Deserializer& text(std::basic_string<T>& str, size_t maxSize) {
+            size_t size;
+            readSize(size, maxSize);
+            if (_isValid) {
+                str.resize(size);
+                procContainer<VSIZE>(std::begin(str), std::end(str), std::true_type{});
+            }
+            return *this;
         }
 
-        template<size_t VSIZE, typename T>
-        void text(T &str) {
-            static_assert(details::IsTextTraitsDefined<T>::value,
-                          "Please define TextTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use text(T&, size_t) overload with `maxSize` for dynamic containers");
-            size_t length;
-            details::readSize(_reader, length, traits::ContainerTraits<T>::size(str));
-            procText<VSIZE>(str, length);
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& text(T (&str)[N]) {
+            size_t size;
+            readSize(size, N-1);
+            if (_isValid) {
+                auto first = std::begin(str);
+                procContainer<VSIZE>(first, std::next(first, size), std::true_type{});
+                //null-terminated string
+                str[size] = {};
+            }
+            return *this;
         }
 
         /*
          * container overloads
          */
 
-        //dynamic size containers
-
-        template<typename T, typename Fnc>
-        void container(T &obj, size_t maxSize, Fnc &&fnc) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(T&) overload without `maxSize` for static containers");
-            size_t size{};
-            details::readSize(_reader, size, maxSize);
-            traits::ContainerTraits<T>::resize(obj, size);
-            procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+        template <typename T, typename Fnc>
+        Deserializer& container(T&& obj, size_t maxSize, Fnc&& fnc) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+            }
+            return *this;
         }
 
-        template<size_t VSIZE, typename T>
-        void container(T &obj, size_t maxSize) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(T&) overload without `maxSize` for static containers");
-            size_t size{};
-            details::readSize(_reader, size, maxSize);
-            traits::ContainerTraits<T>::resize(obj, size);
-            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
+        template <size_t VSIZE, typename T>
+        Deserializer& container(T& obj, size_t maxSize) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer<VSIZE>(std::begin(obj), std::end(obj), std::false_type{});
+            }
+            return *this;
         }
 
-        template<typename T>
-        void container(T &obj, size_t maxSize) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(T&) overload without `maxSize` for static containers");
-            size_t size{};
-            details::readSize(_reader, size, maxSize);
-            traits::ContainerTraits<T>::resize(obj, size);
-            procContainer(std::begin(obj), std::end(obj));
-        }
-        //fixed size containers
-
-        template<typename T, typename Fnc, typename std::enable_if<!std::is_integral<Fnc>::value>::type * = nullptr>
-        void container(T &obj, Fnc &&fnc) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(T&, size_t, Fnc) overload with `maxSize` for dynamic containers");
-            procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+        template <typename T>
+        Deserializer& container(T& obj, size_t maxSize) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer(std::begin(obj), std::end(obj));
+            }
+            return *this;
         }
 
-        template<size_t VSIZE, typename T>
-        void container(T &obj) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(T&, size_t) overload with `maxSize` for dynamic containers");
-            static_assert(VSIZE > 0, "");
-            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
+        /*
+         * array overloads (fixed size array (std::array, and c-style array))
+         */
+
+        //std::array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Deserializer&  array(std::array<T,N> &arr, Fnc && fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
         }
 
-        template<typename T>
-        void container(T &obj) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(T&, size_t) overload with `maxSize` for dynamic containers");
-            procContainer(std::begin(obj), std::end(obj));
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer&  array(std::array<T,N> &arr) {
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
         }
 
-        void align() {
+        template<typename T, size_t N>
+        Deserializer&  array(std::array<T,N> &arr) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+
+        //c-style array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Deserializer& array(T (&arr)[N], Fnc&& fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& array(T (&arr)[N]) {
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Deserializer& array(T (&arr)[N]) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+        bool isValid() const {
+            return _isValid;
+        }
+
+        Deserializer& align() {
             _reader.align();
+            return *this;
         }
 
         //overloads for functions with explicit type size
+        template<typename T> Deserializer& value1(T &&v) { return value<1>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value2(T &&v) { return value<2>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value4(T &&v) { return value<4>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value8(T &&v) { return value<8>(std::forward<T>(v)); }
 
-        template<typename T>
-        void value1b(T &&v) { value<1>(std::forward<T>(v)); }
+        template<typename T, size_t N> Deserializer& substitution1
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<1>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution2
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<2>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution4
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<4>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution8
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<8>(v, expectedValues); };
 
-        template<typename T>
-        void value2b(T &&v) { value<2>(std::forward<T>(v)); }
+        template<typename T> Deserializer& text1(std::basic_string<T> &str, size_t maxSize) {
+            return text<1>(str, maxSize); }
+        template<typename T> Deserializer& text2(std::basic_string<T> &str, size_t maxSize) {
+            return text<2>(str, maxSize); }
+        template<typename T> Deserializer& text4(std::basic_string<T> &str, size_t maxSize) {
+            return text<4>(str, maxSize); }
 
-        template<typename T>
-        void value4b(T &&v) { value<4>(std::forward<T>(v)); }
+        template<typename T, size_t N> Deserializer& text1(T (&str)[N]) { return text<1>(str); }
+        template<typename T, size_t N> Deserializer& text2(T (&str)[N]) { return text<2>(str); }
+        template<typename T, size_t N> Deserializer& text4(T (&str)[N]) { return text<4>(str); }
 
-        template<typename T>
-        void value8b(T &&v) { value<8>(std::forward<T>(v)); }
-
-        template<typename T, typename Ext>
-        void ext1b(T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T, typename Ext>
-        void ext2b(T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T, typename Ext>
-        void ext4b(T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T, typename Ext>
-        void ext8b(T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T>
-        void text1b(T &str, size_t maxSize) { text<1>(str, maxSize); }
-
-        template<typename T>
-        void text2b(T &str, size_t maxSize) { text<2>(str, maxSize); }
-
-        template<typename T>
-        void text4b(T &str, size_t maxSize) { text<4>(str, maxSize); }
-
-        template<typename T>
-        void text1b(T &str) { text<1>(str); }
-
-        template<typename T>
-        void text2b(T &str) { text<2>(str); }
-
-        template<typename T>
-        void text4b(T &str) { text<4>(str); }
-
-        template<typename T>
-        void container1b(T &&obj, size_t maxSize) { container<1>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container2b(T &&obj, size_t maxSize) { container<2>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container4b(T &&obj, size_t maxSize) { container<4>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container8b(T &&obj, size_t maxSize) { container<8>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container1b(T &&obj) { container<1>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container2b(T &&obj) { container<2>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container4b(T &&obj) { container<4>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container8b(T &&obj) { container<8>(std::forward<T>(obj)); }
+        template<typename T> Deserializer& container1(T &&obj, size_t maxSize) {
+            return container<1>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container2(T &&obj, size_t maxSize) {
+            return container<2>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container4(T &&obj, size_t maxSize) {
+            return container<4>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container8(T &&obj, size_t maxSize) {
+            return container<8>(std::forward<T>(obj), maxSize); }
 
     private:
-        friend AdapterAccess;
-
-        TAdapterReader _reader;
-        TContext* _context;
-        typename TReader::TConfig::InternalContext _internalContext;
-
+        Reader& _reader;
+        bool _isValid;
+        void readSize(size_t &size, size_t maxSize) {
+            size = {};
+            if (_isValid) {
+                unsigned char firstBit;
+                _isValid = _reader.readBits(firstBit, 1);
+                if (_isValid) {
+                    if (firstBit) {
+                        _isValid = _reader.readBits(size, 7);
+                    } else {
+                        unsigned char secondBit;
+                        _isValid = _reader.readBits(secondBit, 1);
+                        if (_isValid) {
+                            if (secondBit) {
+                                _isValid = _reader.readBits(size,14);
+                            } else {
+                                _isValid = _reader.readBits(size,30);
+                            }
+                        }
+                    }
+                }
+                if (_isValid)
+                    _isValid = size <= maxSize;
+            }
+        }
 
         //process value types
         //false_type means that we must process all elements individually
         template<size_t VSIZE, typename It>
         void procContainer(It first, It last, std::false_type) {
-            for (; first != last; ++first)
+            for (;_isValid && first != last; ++first)
                 value<VSIZE>(*first);
-        }
+        };
 
         //process value types
         //true_type means, that we can copy whole buffer
         template<size_t VSIZE, typename It>
         void procContainer(It first, It last, std::true_type) {
-            using TValue = typename std::decay<decltype(*first)>::type;
-            using TIntegral = typename details::IntegralFromFundamental<TValue>::TValue;
-            if (first != last)
-                _reader.template readBuffer<VSIZE>(reinterpret_cast<TIntegral*>(&(*first)), std::distance(first, last));
-        }
+            if (_isValid && first != last)
+                _isValid = _reader.template readBuffer<VSIZE>(&(*first), std::distance(first, last));
+        };
 
         //process by calling functions
         template<typename It, typename Fnc>
         void procContainer(It first, It last, Fnc fnc) {
-            for (; first != last; ++first)
-                fnc(*first);
-        }
+            for (;_isValid && first != last; ++first)
+                fnc(*this, *first);
+        };
 
         //process object types
         template<typename It>
         void procContainer(It first, It last) {
-            for (; first != last; ++first)
+            for (;_isValid && first != last; ++first)
                 object(*first);
-        }
-
-        template <size_t VSIZE, typename T>
-        void procText(T& str, size_t length) {
-            auto begin = std::begin(str);
-            //end of string, not end of container
-            auto end = std::next(begin, length);
-            procContainer<VSIZE>(begin, end, std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
-            //null terminated character at the end
-            if (traits::TextTraits<T>::addNUL)
-                *end = {};
-        }
-
-        //proc bool writing bit or byte, depending on if BitPackingEnabled or not
-        void procBoolValue(bool &v, std::true_type) {
-            uint8_t tmp{};
-            _reader.readBits(tmp, 1);
-            v = tmp == 1;
-        }
-
-        void procBoolValue(bool &v, std::false_type) {
-            unsigned char tmp;
-            _reader.template readBytes<1>(tmp);
-            if (tmp > 1)
-                _reader.setError(ReaderError::InvalidData);
-            v = tmp == 1;
-        }
-
-
-        //enable bit-packing or do nothing if it is already enabled
-        template <typename Fnc>
-        void procEnableBitPacking(const Fnc& fnc, std::true_type) {
-            fnc(*this);
-        }
-
-        template <typename Fnc>
-        void procEnableBitPacking(const Fnc& fnc, std::false_type) {
-            //create serializer using bitpacking wrapper
-            BPEnabledType tmp(_reader, _context);
-            fnc(tmp);
-        }
-
-        //these are dummy functions for extensions that have TValue = void
-        void object(details::DummyType&) {
-
-        }
-
-        template <size_t VSIZE>
-        void value(details::DummyType&) {
-
-        }
-
-        //dummy function, that stops archive variadic arguments expansion
-        void archive() {
-        }
+        };
 
     };
 
-    //helper type
-    template <typename Adapter>
-    using Deserializer = BasicDeserializer<AdapterReader<Adapter, DefaultConfig>>;
-
-    //helper function that set ups all the basic steps and after deserialziation returns status
-    template <typename Adapter, typename T>
-    std::pair<ReaderError, bool> quickDeserialization(Adapter adapter, T& value) {
-        Deserializer<Adapter> des{std::move(adapter)};
-        des.object(value);
-        auto& r = AdapterAccess::getReader(des);
-        return {r.error(), r.isCompletedSuccessfully()};
-    }
 
 }
 

include/bitsery/details/adapter_utils.h

@@ -1,87 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_DETAILS_ADAPTER_UTILS_H
-#define BITSERY_DETAILS_ADAPTER_UTILS_H
-
-#include <cassert>
-#include <cstdint>
-#include <cstddef>
-
-namespace bitsery {
-
-    enum class ReaderError {
-        NoError,
-        ReadingError, // this might be used with stream adapter
-        DataOverflow,
-        InvalidData,
-        InvalidPointer
-    };
-
-    namespace details {
-/*
- * size read/write functions
- */
-        template <typename Reader>
-        void readSize(Reader& r, size_t& size, size_t maxSize) {
-            uint8_t hb{};
-            r.template readBytes<1>(hb);
-            if (hb < 0x80u) {
-                size = hb;
-            } else {
-                uint8_t lb{};
-                r.template readBytes<1>(lb);
-                if (hb & 0x40u) {
-                    uint16_t lw{};
-                    r.template readBytes<2>(lw);
-                    size = ((((hb & 0x3Fu) << 8) | lb) << 16) | lw;
-                } else {
-                    size = ((hb & 0x7Fu) << 8) | lb;
-                }
-            }
-            if (size > maxSize) {
-                r.setError(ReaderError::InvalidData);
-                size = {};
-            }
-        }
-
-        template <typename Writter>
-        void writeSize(Writter& w, const size_t size) {
-            if (size < 0x80u) {
-                w.template writeBytes<1>(static_cast<uint8_t>(size));
-            } else {
-                if (size < 0x4000u) {
-                    w.template writeBytes<1>(static_cast<uint8_t>((size >> 8) | 0x80u));
-                    w.template writeBytes<1>(static_cast<uint8_t>(size));
-                } else {
-                    assert(size < 0x40000000u);
-                    w.template writeBytes<1>(static_cast<uint8_t>((size >> 24) | 0xC0u));
-                    w.template writeBytes<1>(static_cast<uint8_t>(size >> 16));
-                    w.template writeBytes<2>(static_cast<uint16_t>(size));
-                }
-            }
-        }
-
-    }
-}
-
-#endif //BITSERY_DETAILS_ADAPTER_UTILS_H

include/bitsery/details/buffer_common.h

@@ -20,34 +20,28 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-#ifndef BITSERY_DETAILS_ADAPTER_COMMON_H
-#define BITSERY_DETAILS_ADAPTER_COMMON_H
-
-#include <algorithm>
-#include <utility>
-#include <cassert>
-#include <vector>
-#include <stack>
-#include <cstring>
-#include "adapter_utils.h"
-#include "not_defined_type.h"
-
-#include "../common.h"
+#ifndef BITSERY_BUFFER_COMMON_H
+#define BITSERY_BUFFER_COMMON_H
 
 namespace bitsery {
 
+/*
+ * endianess
+ */
+    enum class EndiannessType {
+        LittleEndian,
+        BigEndian
+    };
+
     namespace details {
-
         template<typename T>
-        struct BitsSize:public std::integral_constant<size_t, sizeof(T) * 8> {
-
-        };
+        constexpr size_t BITS_SIZE = sizeof(T) << 3;
 
         //add swap functions to class, to avoid compilation warning about unused functions
-        struct SwapImpl {
+        struct swapImpl {
             static uint64_t exec(uint64_t value) {
 #ifdef __GNUC__
-                return __builtin_bswap64(value);
+                return __builtin_bswap64( value );
 #else
                 value = ( value & 0x00000000FFFFFFFF ) << 32 | ( value & 0xFFFFFFFF00000000 ) >> 32;
             value = ( value & 0x0000FFFF0000FFFF ) << 16 | ( value & 0xFFFF0000FFFF0000 ) >> 16;
@@ -56,16 +50,18 @@ namespace bitsery {
 #endif
             }
 
-            static uint32_t exec(uint32_t value) {
+            static uint32_t exec(uint32_t value)
+            {
 #ifdef __GNUC__
-                return __builtin_bswap32(value);
+                return __builtin_bswap32( value );
 #else
                 return ( value & 0x000000ff ) << 24 | ( value & 0x0000ff00 ) << 8 | ( value & 0x00ff0000 ) >> 8 | ( value & 0xff000000 ) >> 24;
 #endif
             }
 
-            static uint16_t exec(uint16_t value) {
-                return (value & 0x00ff) << 8 | (value & 0xff00) >> 8;
+            static uint16_t exec(uint16_t value)
+            {
+                return ( value & 0x00ff ) << 8 | ( value & 0xff00 ) >> 8;
             }
 
             static uint8_t exec(uint8_t value) {
@@ -73,55 +69,28 @@ namespace bitsery {
             }
         };
 
-        template<typename TValue>
+        template <typename TValue>
         TValue swap(TValue value) {
             constexpr size_t TSize = sizeof(TValue);
             using UT = typename std::conditional<TSize == 1, uint8_t,
                     typename std::conditional<TSize == 2, uint16_t,
-                            typename std::conditional<TSize == 4, uint32_t, uint64_t>::type>::type>::type;
-            return SwapImpl::exec(static_cast<UT>(value));
+                            typename std::conditional<TSize == 4, uint32_t , uint64_t>::type>::type>::type;
+            return swapImpl::exec(static_cast<UT>(value));
         }
 
         //add test data in separate struct, because some compilers only support constexpr functions with return-only body
         struct EndiannessTestData {
             static constexpr uint32_t _sample4Bytes = 0x01020304;
-            static constexpr uint8_t _sample1stByte = (const uint8_t &) _sample4Bytes;
+            static constexpr uint8_t _sample1stByte = (const uint8_t&)_sample4Bytes;
         };
 
         constexpr EndiannessType getSystemEndianness() {
-            static_assert(EndiannessTestData::_sample1stByte == 0x04 || EndiannessTestData::_sample1stByte == 0x01,
-                          "system must be either little or big endian");
-            return EndiannessTestData::_sample1stByte == 0x04 ? EndiannessType::LittleEndian
-                                                              : EndiannessType::BigEndian;
+            static_assert(EndiannessTestData::_sample1stByte == 0x04 || EndiannessTestData::_sample1stByte == 0x01, "system must be either little or big endian");
+            return EndiannessTestData::_sample1stByte == 0x04 ? EndiannessType::LittleEndian : EndiannessType::BigEndian;
         }
 
-
-        template<typename T>
-        struct ScratchType {
-            using type = NotDefinedType;
-        };
-
-        template<>
-        struct ScratchType<uint8_t> {
-            using type = uint16_t;
-        };
-
-        /*
-         * class used by session reader, to access underlying iterators of buffer
-         */
-        struct SessionAccess {
-            template <typename TReader, typename Iterator>
-            static Iterator& posIteratorRef(TReader& r) {
-                return r.posIt;
-            }
-            template <typename TReader, typename Iterator>
-            static Iterator& endIteratorRef(TReader& r) {
-                return r.endIt;
-            }
-        };
-
     }
 }
 
 
-#endif //BITSERY_DETAILS_ADAPTER_COMMON_H
+#endif //BITSERY_BUFFER_COMMON_H

include/bitsery/details/flexible_common.h

@@ -1,149 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_DETAILS_FLEXIBLE_COMMON_H
-#define BITSERY_DETAILS_FLEXIBLE_COMMON_H
-
-#include "../traits/core/traits.h"
-#include <limits>
-
-namespace bitsery {
-    namespace flexible {
-
-        //these function overloads is required to apply maxSize, and optimize for fundamental types
-        //for contigous arrays of fundamenal types, memcpy will be applied
-
-        template<typename S, typename T, typename std::enable_if<
-                details::IsFundamentalType<typename traits::ContainerTraits<T>::TValue>::value
-                && traits::ContainerTraits<T>::isResizable
-        >::type * = nullptr>
-        void processContainer(S &s, T &c, size_t maxSize = std::numeric_limits<size_t>::max()) {
-            using TValue = typename traits::ContainerTraits<T>::TValue;
-            s.template container<sizeof(TValue)>(c, maxSize);
-        }
-
-        template<typename S, typename T, typename std::enable_if<
-                !details::IsFundamentalType<typename traits::ContainerTraits<T>::TValue>::value
-                && traits::ContainerTraits<T>::isResizable
-        >::type * = nullptr>
-        void processContainer(S &s, T &c, size_t maxSize = std::numeric_limits<size_t>::max()) {
-            s.container(c, maxSize);
-        }
-
-        template<typename S, typename T, typename std::enable_if<
-                details::IsFundamentalType<typename traits::ContainerTraits<T>::TValue>::value
-                && !traits::ContainerTraits<T>::isResizable
-        >::type * = nullptr>
-        void processContainer(S &s, T &c) {
-            using TValue = typename traits::ContainerTraits<T>::TValue;
-            s.template container<sizeof(TValue)>(c);
-        }
-
-        template<typename S, typename T, typename std::enable_if<
-                !details::IsFundamentalType<typename traits::ContainerTraits<T>::TValue>::value
-                && !traits::ContainerTraits<T>::isResizable
-        >::type * = nullptr>
-        void processContainer(S &s, T &c) {
-            s.container(c);
-        }
-
-        //overloads for text processing to apply maxSize
-
-        template<typename S, typename T, typename std::enable_if<
-                traits::ContainerTraits<T>::isResizable>::type * = nullptr>
-        void processText(S &s, T &c, size_t maxSize = std::numeric_limits<size_t>::max()) {
-            using TValue = typename traits::ContainerTraits<T>::TValue;
-            s.template text<sizeof(TValue)>(c, maxSize);
-        }
-
-        template<typename S, typename T, typename std::enable_if<
-                !traits::ContainerTraits<T>::isResizable>::type * = nullptr>
-        void processText(S &s, T &c) {
-            using TValue = typename traits::ContainerTraits<T>::TValue;
-            s.template text<sizeof(TValue)>(c);
-        }
-
-
-        //all wrapper functions, that modify behaviour, should inherit from this
-        struct ArchiveWrapperFnc {
-
-        };
-
-        //this type is used to differentiate between container and text behaviour
-        template<typename T, size_t N, bool isText>
-        struct CArray : public ArchiveWrapperFnc {
-            CArray(T (&data_)[N]) : data{data_} {};
-            T (&data)[N];
-        };
-
-        template<typename S, typename T, size_t N>
-        void serialize(S &s, CArray<T, N, true> &str) {
-            processText(s, str.data);
-        }
-
-        template<typename S, typename T, size_t N>
-        void serialize(S &s, CArray<T, N, false> &obj) {
-            processContainer(s, obj.data);
-        }
-
-        //used to set max container size
-        template<typename T>
-        struct MaxSize : public ArchiveWrapperFnc {
-            MaxSize(T &data_, size_t maxSize_) : data{data_}, maxSize{maxSize_} {};
-            T &data;
-            size_t maxSize;
-        };
-
-        //if container, then call procesContainer, this memcpy for fundamental types contiguous container
-        template<typename S, typename T>
-        void processMaxSize(S &s, T& data, size_t maxSize, std::true_type) {
-            processContainer(s, data, maxSize);
-        }
-
-        //overload for const T&
-        template<typename S, typename T>
-        void processMaxSize(S &s, const T& data, size_t maxSize, std::true_type) {
-            processContainer(s, const_cast<T&>(data), maxSize);
-        }
-
-
-        //try to call serialize overload with maxsize, extensions use this technique
-        template<typename S, typename T>
-        void processMaxSize(S &s, T& data, size_t maxSize, std::false_type) {
-            serialize(s, data, maxSize);
-        }
-
-        //overload for const T&
-        template<typename S, typename T>
-        void processMaxSize(S &s, const T& data, size_t maxSize, std::false_type) {
-            serialize(s, const_cast<T&>(data), maxSize);
-        }
-
-        template<typename S, typename T>
-        void serialize(S &s, const MaxSize<T> &ms) {
-            processMaxSize(s, ms.data, ms.maxSize, details::IsContainerTraitsDefined<typename std::decay<T>::type>{});
-        }
-
-    }
-}
-
-#endif //BITSERY_DETAILS_FLEXIBLE_COMMON_H

include/bitsery/details/not_defined_type.h

@@ -1,79 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_DETAILS_NOT_DEFINED_TYPE_H
-#define BITSERY_DETAILS_NOT_DEFINED_TYPE_H
-
-#include <iterator>
-
-namespace bitsery {
-    namespace details {
-        //this type is used to show clearer error messages
-        struct NotDefinedType {
-            //just swallow anything that is passed during creating
-            template <typename ... T>
-            NotDefinedType(T&& ...){}
-            NotDefinedType() = default;
-            //define operators so that we also swallow deeper errors, to reduce error stack
-            //this time will be used as iterator, so define all operators nessesarry to work with iterators
-            friend bool operator == (const NotDefinedType&, const NotDefinedType&) {
-                return true;
-            }
-            friend bool operator != (const NotDefinedType&, const NotDefinedType&) {
-                return false;
-            }
-            NotDefinedType& operator += (int) {
-                return *this;
-            }
-            NotDefinedType& operator -= (int) {
-                return *this;
-            }
-
-            friend int operator - (const NotDefinedType&, const NotDefinedType&) {
-                return 0;
-            }
-
-            int& operator*() {
-                return data;
-            }
-            int data;
-        };
-
-        template <typename T>
-        struct IsDefined:public std::integral_constant<bool, !std::is_same<NotDefinedType, T>::value> {
-        };
-    }
-}
-
-namespace std {
-    //define iterator traits to work with standart algorithms
-    template <>
-    struct iterator_traits<bitsery::details::NotDefinedType> {
-        using difference_type = int;
-        using value_type = int;
-        using pointer = int*;
-        using reference = int&;
-        using iterator_category = std::random_access_iterator_tag;
-    };
-}
-#endif //BITSERY_DETAILS_NOT_DEFINED_TYPE_H

include/bitsery/details/serialization_common.h

@@ -20,382 +20,220 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-#ifndef BITSERY_DETAILS_SERIALIZATION_COMMON_H
-#define BITSERY_DETAILS_SERIALIZATION_COMMON_H
+#ifndef BITSERY_SERIALIZATION_COMMON_H
+#define BITSERY_SERIALIZATION_COMMON_H
 
+#include <cstdint>
 #include <type_traits>
-#include <utility>
-#include <tuple>
-#include "adapter_utils.h"
-#include "../traits/core/traits.h"
-
+#include <array>
 
 namespace bitsery {
 
-    //this allows to call private serialize method for the class
-    //just make friend it to that class
-    struct Access {
-        template<typename S, typename T>
-        static auto serialize(S &s, T &obj) -> decltype(obj.serialize(s)) {
-            obj.serialize(s);
+    namespace details {
+
+        template<typename T, typename Enable = void>
+        struct SAME_SIZE_UNSIGNED_TYPE {
+            typedef std::make_unsigned_t<T> type;
+        };
+
+        template<typename T>
+        struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+            typedef std::make_unsigned_t<std::underlying_type_t<T>> type;
+        };
+
+        template<typename T>
+        struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+            typedef std::conditional_t<std::is_same<T, float>::value, uint32_t, uint64_t> type;
+        };
+
+        template<typename T>
+        using SAME_SIZE_UNSIGNED = typename SAME_SIZE_UNSIGNED_TYPE<T>::type;
+
+        template <typename T>
+        constexpr size_t getSize(T v, size_t s) {
+            return v > 0 ? getSize(v / 2, s + 1) : s;
         }
+
+        template<typename T>
+        constexpr size_t calcRequiredBits(T min, T max) {
+            //call recursive function, because some compilers only support constexpr functions with return-only body
+            return getSize(max - min, 0);
+        }
+
+    }
+
+/*
+ * range functions in bitsery namespace because these are used by user
+ */
+
+    template<typename T, typename Enable = void>
+    struct RangeSpec {
+
+        constexpr RangeSpec(T minValue, T maxValue)
+                : min{minValue},
+                  max{maxValue},
+                  bitsRequired{details::calcRequiredBits(min, max)} {
+        }
+
+        const T min;
+        const T max;
+        const size_t bitsRequired;
     };
 
-    //when call to serialize function is ambiguous (member and non-member serialize function exists for a type)
-    //specialize this class, by inheriting from either UseNonMemberFnc or UseMemberFnc
-    //e.g.
-    //template <> struct SelectSerializeFnc<MyDerivedClass>:UseMemberFnc {};
+
     template<typename T>
-    struct SelectSerializeFnc : std::integral_constant<int, 0> {
-    };
+    struct RangeSpec<T, typename std::enable_if<std::is_enum<T>::value>::type> {
 
-    //types you need to inherit from when specializing SelectSerializeFnc class
-    struct UseNonMemberFnc : std::integral_constant<int, 1> {
-    };
-    struct UseMemberFnc : std::integral_constant<int, 2> {
-    };
-
-
-    //serializer/deserializer, does not public interface to get underlying writer/reader
-    //to prevent users from using writer/reader directly, because they have different interface
-    //and they cannot be used describing serialization flows.: use extensions for this reason.
-    //this class allows to get underlying adapter writer/reader, and only should be used outside serialization functions.
-    struct AdapterAccess {
-        template<typename Serializer>
-        static typename Serializer::TWriter &getWriter(Serializer &s) {
-            return s._writer;
+        constexpr RangeSpec(T minValue, T maxValue) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{details::calcRequiredBits(
+                        static_cast<std::underlying_type_t<T>>(min),
+                        static_cast<std::underlying_type_t<T>>(max))} {
         }
 
-        template<typename Deserializer>
-        static typename Deserializer::TReader &getReader(Deserializer &s) {
-            return s._reader;
+        const T min;
+        const T max;
+        const size_t bitsRequired;
+    };
+
+//this class is used to make default RangeSpec float specialization always prefer constructor with precision
+    struct BitsConstraint {
+        explicit constexpr BitsConstraint(size_t bits) : value{bits} {}
+
+        const size_t value;
+    };
+
+    template<typename T>
+    struct RangeSpec<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+
+        constexpr RangeSpec(T minValue, T maxValue, BitsConstraint bits) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{bits.value} {
         }
+
+        constexpr RangeSpec(T minValue, T maxValue, T precision) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{details::calcRequiredBits<details::SAME_SIZE_UNSIGNED<T>>({}, ((max - min) / precision))} {
+
+        }
+
+        const T min;
+        const T max;
+        const size_t bitsRequired;
     };
 
     namespace details {
 
-        //helper types for error handling
-        template<typename T>
-        struct IsContainerTraitsDefined : public IsDefined<typename traits::ContainerTraits<T>::TValue> {
+/*
+ * functions for range
+ */
+
+        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            return static_cast<SAME_SIZE_UNSIGNED<T>>(v - r.min);
         };
 
-        template<typename T>
-        struct IsTextTraitsDefined : public IsDefined<typename traits::TextTraits<T>::TValue> {
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            return static_cast<SAME_SIZE_UNSIGNED<T>>(v) - static_cast<SAME_SIZE_UNSIGNED<T>>(r.min);
         };
 
-        template<typename Ext, typename T>
-        struct IsExtensionTraitsDefined : public IsDefined<typename traits::ExtensionTraits<Ext, T>::TValue> {
+        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            using VT = SAME_SIZE_UNSIGNED<T>;
+            const VT maxUint = (static_cast<VT>(1) << r.bitsRequired) - 1;
+            const auto ratio = (v - r.min) / (r.max - r.min);
+            return static_cast<VT>(ratio * maxUint);
         };
 
-#ifdef _MSC_VER
-        //helper types for HasSerializeFunction
-        template <typename S, typename T>
-        using TrySerializeFunction = decltype(serialize(std::declval<S &>(), std::declval<T &>()));
-
-        template <typename S, typename T>
-        struct HasSerializeFunctionHelper {
-            template <typename Q, typename R, typename = TrySerializeFunction<Q, R>>
-            static std::true_type tester(Q&&, R&&);
-            static std::false_type tester(...);
-            using type = decltype(tester(std::declval<S>(), std::declval<T>()));
-        };
-        template <typename S, typename T>
-        struct HasSerializeFunction :HasSerializeFunctionHelper<S, T>::type {};
-
-        //helper types for HasSerializeMethod
-        template <typename S, typename T>
-        using TrySerializeMethod = decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()));
-
-        template <typename S, typename T>
-        struct HasSerializeMethodHelper {
-            template <typename Q, typename R, typename = TrySerializeMethod<Q, R>>
-            static std::true_type tester(Q&&, R&&);
-            static std::false_type tester(...);
-            using type = decltype(tester(std::declval<S>(), std::declval<T>()));
-        };
-        template <typename S, typename T>
-        struct HasSerializeMethod :HasSerializeMethodHelper<S, T>::type {};
-
-        //helper types for IsFlexibleIncluded
-        template <typename S, typename T>
-        using TryArchiveProcess = decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()));
-
-        template <typename S, typename T>
-        struct IsFlexibleIncludedHelper {
-            template <typename Q, typename R, typename = TryArchiveProcess<Q, R>>
-            static std::true_type tester(Q&&, R&&);
-            static std::false_type tester(...);
-            using type = decltype(tester(std::declval<S>(), std::declval<T>()));
+        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            v += r.min;
         };
 
-        template <typename S, typename T>
-        struct IsFlexibleIncluded :IsFlexibleIncludedHelper<S, T>::type {};
-#else
-        //helper metafunction, that is added to c++17
-        template<typename... Ts>
-        struct make_void {
-            typedef void type;
-        };
-        template<typename... Ts>
-        using void_t = typename make_void<Ts...>::type;
-
-        template<typename, typename, typename = void>
-        struct HasSerializeFunction : std::false_type {
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            using VT = std::underlying_type_t<T>;
+            reinterpret_cast<VT&>(v) += static_cast<VT>(r.min);
         };
 
-        template<typename S, typename T>
-        struct HasSerializeFunction<S, T,
-                void_t<decltype(serialize(std::declval<S &>(), std::declval<T &>()))>
-        > : std::true_type {
+        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            using UIT = SAME_SIZE_UNSIGNED<T>;
+            const auto intRep = reinterpret_cast<UIT&>(v);
+            const UIT maxUint = (static_cast<UIT>(1) << r.bitsRequired) - 1;
+            v = r.min + (static_cast<T>(intRep) / maxUint) * (r.max - r.min);
         };
 
+        template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type * = nullptr>
+        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
+            return !(r.min > v || v > r.max);
+        }
 
-        template<typename, typename, typename = void>
-        struct HasSerializeMethod : std::false_type {
-        };
-
-        template<typename S, typename T>
-        struct HasSerializeMethod<S, T,
-                void_t<decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()))>
-        > : std::true_type {
-        };
-
-        //this solution doesn't work with visual studio, but is more elegant
-        template<typename, typename, typename = void>
-        struct IsFlexibleIncluded : std::false_type {
-        };
-
-        template<typename S, typename T>
-        struct IsFlexibleIncluded<S, T,
-                void_t<decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()))>
-        > : std::true_type {
-        };
-#endif
-
-
-        //used for extensions, when extension TValue = void
-        struct DummyType {
-        };
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
+            using VT = std::underlying_type_t<T>;
+            return !(static_cast<VT>(r.min) > static_cast<VT>(v)
+                     || static_cast<VT>(v) > static_cast<VT>(r.max));
+        }
 
 /*
- * this includes all integral types floats and enums(except bool)
+ * functions for substitution
  */
-        template<typename T>
-        struct IsFundamentalType : std::integral_constant<bool,
-                std::is_enum<T>::value
-                || std::is_floating_point<T>::value
-                || std::is_integral<T>::value> {
-        };
 
-        template<typename T, typename Integral = void>
-        struct IntegralFromFundamental {
-            using TValue = T;
+        template<typename T, size_t N>
+        size_t findSubstitutionIndex(const T &v, const std::array<T, N> &defValues) {
+            auto index{1u};
+            for (auto &d:defValues) {
+                if (d == v)
+                    return index;
+                ++index;
+            }
+            return 0u;
         };
 
-        template<typename T>
-        struct IntegralFromFundamental<T, typename std::enable_if<std::is_enum<T>::value>::type> {
-            using TValue = typename std::underlying_type<T>::type;
-        };
-
-        template<typename T>
-        struct IntegralFromFundamental<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-            using TValue = typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type;
-        };
-
-        template<typename T>
-        struct UnsignedFromFundamental {
-            using type = typename std::make_unsigned<typename IntegralFromFundamental<T>::TValue>::type;
-        };
-
-        template<typename T>
-        using SameSizeUnsigned = typename UnsignedFromFundamental<T>::type;
-
 
 /*
- * functions for object serialization
+ * delta functions
  */
 
-        template<typename S, typename T>
-        struct SerializeFunction {
+        class ObjectMemoryPosition {
+        public:
 
-            static void invoke(S &s, T &v) {
-                static_assert(HasSerializeFunction<S, T>::value || HasSerializeMethod<S, T>::value,
-                              "\nPlease define 'serialize' function for your type (inside or outside of class):\n"
-                                      "  template<typename S>\n"
-                                      "  void serialize(S& s)\n"
-                                      "  {\n"
-                                      "    ...\n"
-                                      "  }\n");
-                using TDecayed = typename std::decay<T>::type;
-                selectSerializeFnc(s, v, SelectSerializeFnc<TDecayed>{});
+            template<typename T>
+            ObjectMemoryPosition(const T &oldObj, const T &newObj)
+                    :ObjectMemoryPosition{reinterpret_cast<const char *>(&oldObj), reinterpret_cast<const char *>(&newObj),
+                                          sizeof(T)} {
+            }
+
+            template<typename T>
+            bool isFieldsEquals(const T &newObjField) {
+                return *getOldObjectField(newObjField) == newObjField;
+            }
+
+            template<typename T>
+            const T *getOldObjectField(const T &field) {
+                auto offset = reinterpret_cast<const char *>(&field) - newObj;
+                return reinterpret_cast<const T *>(oldObj + offset);
             }
 
         private:
-            static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 0>) {
-                static_assert(!(HasSerializeFunction<S, T>::value && HasSerializeMethod<S, T>::value),
-                              "\nPlease define only one 'serialize' function (member OR free).\n"
-                                      "If serialization function is inherited from base class, then explicitly select correct function for your type e.g.:\n"
-                                      "  template <>\n"
-                                      "  struct SelectSerializeFnc<DerivedClass>:UseMemberFnc {};\n");
-                selectSerializeFnc(s, v, std::integral_constant<int,
-                        HasSerializeFunction<S, T>::value ? 1 : 2>{});
+
+            ObjectMemoryPosition(const char *objOld, const char *objNew, size_t)
+                    : oldObj{objOld},
+                      newObj{objNew} {
             }
 
-            static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 1>) {
-                serialize(s, v);
-            }
-
-            static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 2>) {
-                Access::serialize(s, v);
-            }
+            const char *oldObj;
+            const char *newObj;
         };
 
-/*
- * functions for object serialization
- */
-
-        template<typename S, typename T, typename Enabled = void>
-        struct ArchiveFunction {
-
-            static void invoke(S &s, T &&obj) {
-                static_assert(IsFlexibleIncluded<S, T>::value,
-                              "\nPlease include '<bitsery/flexible.h>' to use 'archive' function:\n");
-
-                archiveProcess(s, std::forward<T>(obj));
-            }
-        };
-
-        /*
-         * helper function for getting context from serializer/deserializer
-         */
-
-        template<typename T, template<typename...> class Template>
-        struct IsSpecializationOf : std::false_type {
-        };
-
-        template<template<typename...> class Template, typename... Args>
-        struct IsSpecializationOf<Template<Args...>, Template> : std::true_type {
-        };
-
-        //helper types for better error messages
-        template<typename Find, typename ... TList>
-        struct GetTypeIndex : std::integral_constant<size_t, 0> {
-        };
-
-        //found it
-        template<typename Find, typename ... Tail>
-        struct GetTypeIndex<Find, Find, Tail...> : std::integral_constant<size_t, 0> {
-        };
-
-        //iteratates over types
-        template<typename Find, typename Head, typename ... Tail>
-        struct GetTypeIndex<Find, Head, Tail...> : std::integral_constant<size_t,
-                1 + GetTypeIndex<Find, Tail...>::value> {
-        };
-
-        template<typename Find, typename ... TList>
-        struct HasType : std::integral_constant<bool, (GetTypeIndex<Find, TList...>::value<(sizeof ... (TList)))> {
-        };
-
-        template<typename TCast, typename Tuple>
-        struct HasContext : std::is_same<TCast, Tuple> {
-        };
-
-        template<typename TCast, typename ... Args>
-        struct HasContext<TCast, std::tuple<Args...>> : HasType<TCast, Args...> {
-        };
-
-        /*
-         * get context, and static assert if type doesn't exists
-         */
-
-        template<typename TCast, typename ... Args>
-        TCast *getContextImpl(std::tuple<Args...> *ctx, std::true_type) {
-            using TCastIndex = GetTypeIndex<TCast, Args...>;
-            static_assert(HasType<TCast, Args...>::value, "Invalid context cast. Type doesn't exists.");
-            return std::addressof(std::get<TCastIndex::value>(*ctx));
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextImpl(TContext *ctx, std::false_type) {
-            static_assert(std::is_convertible<TContext *, TCast *>::value, "Invalid context cast. Type doesn't exists.");
-            return static_cast<TCast *>(ctx);
-        }
-
-        //get local ctx
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *chooseInternalOrExternalContext(TContext *, TInternalContext &internalCtx, std::true_type) {
-            return getContextImpl<TCast>(&internalCtx, std::true_type{});
-        }
-
-        //get external ctx
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *chooseInternalOrExternalContext(TContext *ctx, TInternalContext &, std::false_type) {
-            return ctx
-                   ? getContextImpl<TCast>(ctx, IsSpecializationOf<TContext, std::tuple>{})
-                   : nullptr;
-        }
-
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *getContext(TContext *ctx, TInternalContext &internalCtx) {
-            return chooseInternalOrExternalContext<TCast>(ctx, internalCtx, HasContext<TCast, TInternalContext>{});
-        }
-
-        /*
-         * get context, if type doesn't exists then do not static_assert but return null instead
-         */
-
-        template<typename TCast, typename TContext>
-        TCast *getContextFromTypeIfExists(TContext *ctx, std::true_type) {
-            return static_cast<TCast *>(ctx);
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextFromTypeIfExists(TContext *, std::false_type) {
-            return nullptr;
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextImplIfExists(TContext *ctx, std::false_type) {
-            return getContextFromTypeIfExists<TCast>(ctx, std::is_convertible<TContext *, TCast *>{});
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextFromTupleIfExists(TContext *ctx, std::true_type tmp) {
-            return getContextImpl<TCast>(ctx, tmp);
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextFromTupleIfExists(TContext *, std::false_type) {
-            return nullptr;
-        }
-
-        template<typename TCast, typename TContext>
-        TCast *getContextImplIfExists(TContext *ctx, std::true_type) {
-            return getContextFromTupleIfExists<TCast>(ctx, HasContext<TCast, TContext>{});
-        }
-
-        //get local ctx
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *chooseInternalOrExternalContextIfExists(TContext *, TInternalContext &internalCtx, std::true_type) {
-            return getContextImplIfExists<TCast>(&internalCtx, std::true_type{});
-        }
-
-        //get external ctx
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *chooseInternalOrExternalContextIfExists(TContext *ctx, TInternalContext &, std::false_type) {
-            return ctx
-                   ? getContextImplIfExists<TCast>(ctx, IsSpecializationOf<TContext, std::tuple>{})
-                   : nullptr;
-        }
-
-        template<typename TCast, typename TContext, typename TInternalContext>
-        TCast *getContextIfTypeExists(TContext *ctx, TInternalContext &internalCtx) {
-            return chooseInternalOrExternalContextIfExists<TCast>(ctx, internalCtx, HasContext<TCast, TInternalContext>{});
-        }
 
     }
+
 }
 
-#endif //BITSERY_DETAILS_SERIALIZATION_COMMON_H
-
+#endif //BITSERY_SERIALIZATION_COMMON_H

include/bitsery/details/sessions.h

@@ -1,228 +0,0 @@
-//
-// Created by fraillt on 17.10.5.
-//
-
-#ifndef BITSERY_DETAILS_SESSIONS_H
-#define BITSERY_DETAILS_SESSIONS_H
-
-#include <vector>
-#include <stack>
-#include "adapter_common.h"
-
-namespace bitsery {
-
-    namespace session {
-        /*
-         * writer/reader implementations that disable session support
-         */
-        template <typename TWriter>
-        struct DisabledSessionsWriter {
-            void begin(TWriter& ) {
-                static_assert(std::is_void<TWriter>::value, "Sessions is disabled, enable it via configuration");
-            }
-            void end(TWriter& ) {
-                static_assert(std::is_void<TWriter>::value, "Sessions is disabled, enable it via configuration");
-            }
-            void flushSessions(TWriter& ) {
-            }
-        };
-
-        template <typename TReader>
-        struct DisabledSessionsReader {
-            template <typename TBufferContext>
-            DisabledSessionsReader(TReader& , TBufferContext& ) {
-            }
-
-            void begin() {
-                static_assert(std::is_void<TReader>::value, "Sessions is disabled, enable it via configuration");
-            }
-
-            void end() {
-                static_assert(std::is_void<TReader>::value, "Sessions is disabled, enable it via configuration");
-            }
-
-            bool hasActiveSessions() const {
-                return false;
-            }
-        };
-
-        /*
-         * writer/reader real implementations
-         * sessions reading requires to have random access iterators, so it cannot be used with streams
-         */
-        template <typename TWriter>
-        class SessionsWriter {
-        public:
-
-            SessionsWriter() = default;
-            SessionsWriter(const SessionsWriter&) = delete;
-            SessionsWriter& operator = (const SessionsWriter& ) = delete;
-
-            SessionsWriter(SessionsWriter&&) = default;
-            SessionsWriter& operator = (SessionsWriter&& ) = default;
-
-            void begin(TWriter& ) {
-                //write position
-                _sessionIndex.push(_sessions.size());
-                _sessions.emplace_back(0);
-            }
-
-            void end(TWriter& writer) {
-                assert(!_sessionIndex.empty());
-                //change position to session end
-                auto sessionIt = std::next(std::begin(_sessions), _sessionIndex.top());
-                _sessionIndex.pop();
-                auto sessionSize = writer.writtenBytesCount();
-                assert(sessionSize > 0);
-                *sessionIt = sessionSize;
-            }
-
-            void flushSessions(TWriter& writer) {
-                if (_sessions.size()) {
-                    assert(_sessionIndex.empty());
-                    auto dataSize = writer.writtenBytesCount();
-                    for(auto& s:_sessions) {
-                        details::writeSize(writer, s);
-                    }
-                    _sessions.clear();
-
-                    auto totalSize = writer.writtenBytesCount();
-                    //write offset where actual data ends
-                    auto sessionsOffset = totalSize - dataSize + 4;//4 bytes for offset data
-                    writer.template writeBytes<4>(static_cast<uint32_t>(sessionsOffset));
-                }
-            }
-        private:
-            std::vector<size_t> _sessions{};
-            std::stack<size_t> _sessionIndex{};
-        };
-
-        template <typename TReader>
-        struct SessionsReader {
-            using TIterator = typename TReader::TIterator;
-
-            template <typename InputAdapter>
-            SessionsReader(TReader& r, InputAdapter& adapter)
-                    :_reader{r},
-                     _beginIt{details::SessionAccess::posIteratorRef<InputAdapter, TIterator>(adapter)},
-                     _posItRef{details::SessionAccess::posIteratorRef<InputAdapter, TIterator>(adapter)},
-                     _endItRef{details::SessionAccess::endIteratorRef<InputAdapter, TIterator>(adapter)}
-            {
-            }
-
-            SessionsReader(const SessionsReader&) = delete;
-            SessionsReader& operator = (const SessionsReader& ) = delete;
-
-            SessionsReader(SessionsReader&&) = default;
-            SessionsReader& operator = (SessionsReader&& ) = default;
-
-            void begin() {
-                if (_sessions.empty()) {
-                    if (!initializeSessions())
-                        return;
-                }
-
-                //save end position for current session
-                _sessionsStack.push(_endItRef);
-                if (_nextSessionIt != std::end(_sessions)) {
-                    if (std::distance(_posItRef, _endItRef) > 0) {
-                        //set end position for new session
-                        auto newEnd = std::next(_beginIt, *_nextSessionIt);
-                        if (std::distance(newEnd, _endItRef) < 0)
-                        {
-                            //new session cannot end further than current end
-                            _reader.setError(ReaderError::InvalidData);
-                            return;
-                        }
-                        _endItRef = newEnd;
-                        ++_nextSessionIt;
-                    }
-                    //if we reached the end, means that there is no more data to read, hence there is no more sessions to advance to
-                } else {
-                    //there is no data to read anymore
-                    //pos == end or buffer overflow while session is active
-                    if (!(_posItRef == _endItRef || _reader.error() == ReaderError::NoError) || !(_sessionsStack.size() > 1)) {
-                        _reader.setError(ReaderError::InvalidData);
-                    }
-                }
-            }
-
-            void end() {
-                if (!_sessionsStack.empty()) {
-                    //move position to the end of session
-                    //can additionaly be checked for session data versioning
-                    //_pos == _end : same versions
-                    //distance(_pos,_end) > 0: reading newer version
-                    //error() == BUFFER_OVERFLOW: reading older version
-                    auto dist = std::distance(_posItRef, _endItRef);
-                    if (dist > 0) {
-                        //newer version might have some inner sessions, try to find the one after current ends
-                        auto currPos = static_cast<size_t>(std::distance(_beginIt, _endItRef));
-                        for (; _nextSessionIt != std::end(_sessions); ++_nextSessionIt) {
-                            if (*_nextSessionIt > currPos)
-                                break;
-                        }
-                    }
-                    //modify pointers only if no error or buffer overflow
-                    if (_reader.error() == ReaderError::NoError || _reader.error() == ReaderError::DataOverflow) {
-                        _posItRef = _endItRef;
-                        //restore end position
-                        _endItRef = _sessionsStack.top();
-                    }
-                    _sessionsStack.pop();
-                }
-            }
-
-            bool hasActiveSessions() const {
-                return _sessionsStack.size() > 0;
-            }
-
-        private:
-            TReader& _reader;
-            TIterator _beginIt;
-            TIterator& _posItRef;
-            TIterator& _endItRef;
-            std::vector<size_t> _sessions{};
-            std::vector<size_t>::iterator _nextSessionIt{};
-            std::stack<TIterator> _sessionsStack{};
-
-            bool initializeSessions() {
-                //save current position
-                auto currPos = _posItRef;
-                //read size
-                if (std::distance(_posItRef, _endItRef) < 4) {
-                    _reader.setError(ReaderError::InvalidData);
-                    return false;
-                }
-                auto endSessionsSizesIt = std::next(_endItRef, -4);
-                _posItRef = endSessionsSizesIt;
-                uint32_t sessionsOffset{};
-                _reader.template readBytes<4>(sessionsOffset);
-
-                auto bufferSize = std::distance(_beginIt, _endItRef);
-                if (static_cast<size_t>(bufferSize) < sessionsOffset) {
-                    _reader.setError(ReaderError::InvalidData);
-                    return false;
-                }
-                //we can initialy resizes to this value, and we'll shrink it after reading
-                //read session sizes
-                auto sessionsIt = std::back_inserter(_sessions);
-                _posItRef = std::next(_endItRef, -static_cast<int32_t>(sessionsOffset));
-                while (std::distance(_posItRef, endSessionsSizesIt) > 0) {
-                    size_t size;
-                    details::readSize(_reader, size, bufferSize);
-                    *sessionsIt++ = size;
-                }
-                _sessions.shrink_to_fit();
-                //set iterators to data
-                _posItRef = currPos;
-                _endItRef = std::next(_endItRef, -static_cast<int32_t>(sessionsOffset));
-                _nextSessionIt = std::begin(_sessions);//set before first session;
-                return true;
-            }
-        };
-
-    }
-}
-
-#endif //BITSERY_DETAILS_SESSIONS_H

include/bitsery/ext/entropy.h

@@ -1,102 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_ENTROPY_H
-#define BITSERY_EXT_ENTROPY_H
-
-#include "value_range.h"
-
-namespace bitsery {
-
-    namespace details {
-        template<typename TValue, typename TContainer>
-        size_t findEntropyIndex(const TValue &v, const TContainer &defValues) {
-            size_t index{1u};
-            for (auto &d:defValues) {
-                if (d == v)
-                    return index;
-                ++index;
-            }
-            return 0u;
-        }
-    }
-
-    namespace ext {
-
-        template<typename TContainer>
-        class Entropy {
-        public:
-
-            /**
-             * Allows entropy-encoding technique, by writing few bits for most common values
-             * @param values list of most common values
-             * @param alignBeforeData only makes sense when bit-packing enabled, by default aligns after writing bits for index
-             */
-            constexpr Entropy(TContainer& values, bool alignBeforeData=true)
-                    : _values{values},
-                      _alignBeforeData{alignBeforeData} {
-            };
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &s, Writer &, const T &obj, Fnc &&fnc) const {
-                assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
-                auto index = details::findEntropyIndex(obj, _values);
-                s.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
-                if (_alignBeforeData)
-                    s.align();
-                if (!index)
-                    fnc(const_cast<T &>(obj));
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &d, Reader &, T &obj, Fnc &&fnc) const {
-                assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
-                size_t index{};
-                d.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
-                if (_alignBeforeData)
-                    d.align();
-                if (index)
-                    obj = *std::next(std::begin(_values), index-1);
-                else
-                    fnc(obj);
-            }
-
-        private:
-            TContainer& _values;
-            bool _alignBeforeData;
-        };
-    }
-
-    namespace traits {
-        template<typename TContainer, typename T>
-        struct ExtensionTraits<ext::Entropy<TContainer>, T> {
-            using TValue = T;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_ENTROPY_H

include/bitsery/ext/inheritance.h

@@ -1,156 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_INHERITANCE_H
-#define BITSERY_EXT_INHERITANCE_H
-
-#include <unordered_set>
-#include "../traits/core/traits.h"
-
-namespace bitsery {
-
-    namespace ext {
-
-        //required when virtual inheritance (ext::VirtualBaseClass) exists in serialization flow.
-        //for standard inheritance (ext::BaseClass) it is optional.
-        class InheritanceContext {
-        public:
-            InheritanceContext() = default;
-            InheritanceContext(const InheritanceContext&) = delete;
-            InheritanceContext&operator = (const InheritanceContext&) = delete;
-            InheritanceContext(InheritanceContext&&) = default;
-            InheritanceContext& operator = (InheritanceContext&&) = default;
-
-            template <typename TDerived, typename TBase>
-            void beginBase(const TDerived &derived, const TBase &) {
-                if (_depth == 0) {
-                    const void* ptr = std::addressof(derived);
-                    if ( _parentPtr != ptr)
-                        _virtualBases.clear();
-                    _parentPtr = ptr;
-                }
-                ++_depth;
-            }
-
-            template <typename TDerived, typename TBase>
-            bool beginVirtualBase(const TDerived &derived, const TBase &base) {
-                beginBase(derived, base);
-                return _virtualBases.emplace(std::addressof(base)).second;
-            }
-
-            void end() {
-                --_depth;
-            }
-
-        private:
-            //these members are required to know when we can clear _virtualBases
-            size_t _depth{};
-            const void* _parentPtr{};
-            //add virtual bases to the list, as long as we're on the same parent
-            std::unordered_set<const void*> _virtualBases{};
-        };
-
-        template <typename TBase>
-        class BaseClass {
-        public:
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
-                auto& resObj = static_cast<const TBase&>(obj);
-                if (auto ctx = ser.template contextOrNull<InheritanceContext>()) {
-                    ctx->beginBase(obj, resObj);
-                    fnc(const_cast<TBase&>(resObj));
-                    ctx->end();
-                } else {
-                    fnc(const_cast<TBase&>(resObj));
-                }
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
-                auto& resObj = static_cast<TBase&>(obj);
-                if (auto ctx = des.template contextOrNull<InheritanceContext>()) {
-                    ctx->beginBase(obj, resObj);
-                    fnc(resObj);
-                    ctx->end();
-                } else {
-                    fnc(resObj);
-                }
-            }
-
-        };
-
-        //requires InheritanceContext
-        template <typename TBase>
-        class VirtualBaseClass {
-        public:
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
-                auto ctx = ser.template context<InheritanceContext>();
-                auto& resObj = static_cast<const TBase&>(obj);
-                if (ctx->beginVirtualBase(obj, resObj))
-                    fnc(const_cast<TBase&>(resObj));
-                ctx->end();
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
-                auto ctx = des.template context<InheritanceContext>();
-                auto& resObj = static_cast<TBase&>(obj);
-                if (ctx->beginVirtualBase(obj, resObj))
-                    fnc(resObj);
-                ctx->end();
-            }
-
-        };
-
-    }
-
-    namespace traits {
-        template<typename TBase, typename T>
-        struct ExtensionTraits<ext::BaseClass<TBase>, T> {
-            static_assert(std::is_base_of<TBase, T>::value, "Invalid base class");
-
-            using TValue = TBase;
-            static constexpr bool SupportValueOverload = false;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-
-        template<typename TBase, typename T>
-        struct ExtensionTraits<ext::VirtualBaseClass<TBase>, T> {
-            static_assert(std::is_base_of<TBase, T>::value, "Invalid base class");
-
-            using TValue = TBase;
-            static constexpr bool SupportValueOverload = false;
-            static constexpr bool SupportObjectOverload = true;
-            //disable lambda overload, when serializing virtually inherited base class.
-            //Only one instance of virtual base will be serialized, when using multiple inheritance
-            //and it will be undefined behaviour if derived classes would have different virtual base class serialization flow.
-            static constexpr bool SupportLambdaOverload = false;
-        };
-    }
-}
-
-
-#endif //BITSERY_EXT_INHERITANCE_H

include/bitsery/ext/optional.h

@@ -20,48 +20,48 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-#ifndef BITSERY_EXT_GROWABLE_H
-#define BITSERY_EXT_GROWABLE_H
 
-#include "../traits/core/traits.h"
+#ifndef BITSERY_EXT_OPTIONAL_H
+#define BITSERY_EXT_OPTIONAL_H
 
 namespace bitsery {
-
     namespace ext {
 
-        /*
-         * enables to add additional serialization methods at the end of method, without breaking existing older code
-         */
-        class Growable {
+        template <typename T>
+        using std_optional = ::std::optional<T>;
+
+        template <typename T>
+        class optional {
         public:
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &obj, Fnc &&fnc) const {
-                writer.beginSession();
-                fnc(const_cast<T&>(obj));
-                writer.endSession();
+            explicit optional(T& v):_value{v} {
+                using TOpt = typename std::remove_cv<T>::type;
+                using TVal = typename TOpt::value_type;
+                static_assert(std::is_same<TOpt, std_optional<TVal>>(), "");
+            };
+            template <typename TSerializer, typename Fnc>
+            void serialize(TSerializer& ser, const Fnc& fnc) {
+                ser.boolByte(static_cast<bool>(_value));
+                if (_value)
+                    fnc(ser, *_value);
             }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &obj, Fnc &&fnc) const {
-                reader.beginSession();
-                fnc(obj);
-                reader.endSession();
+            template <typename TSerializer, typename Fnc>
+            void deserialize(TSerializer& ser, const Fnc& fnc) {
+                bool exists{};
+                ser.boolByte(exists);
+                if (exists) {
+                    typename T::value_type tmp{};
+                    fnc(ser, tmp);
+                    _value = tmp;
+                } else {
+                    _value = T{};
+                }
             }
+        private:
+            T& _value;
         };
-    }
 
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::Growable, T> {
-            using TValue = T;
-            static constexpr bool SupportValueOverload = false;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
     }
-
 }
 
 
-#endif //BITSERY_EXT_GROWABLE_H
+#endif //BITSERY_EXT_OPTIONAL_H

include/bitsery/ext/pointer.h

@@ -1,186 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_POINTER_H
-#define BITSERY_EXT_POINTER_H
-
-#include "../traits/core/traits.h"
-#include "utils/pointer_utils.h"
-#include "utils/rtti_utils.h"
-
-namespace bitsery {
-
-    namespace ext {
-
-        namespace details_pointer {
-
-            template<typename S>
-            PointerLinkingContext &getLinkingContext(S &s) {
-                auto res = s.template context<PointerLinkingContext>();
-                assert(res != nullptr);
-                return *res;
-            }
-
-
-            template<typename TObject>
-            struct RawPointerObjectHandler {
-
-                using TPointer = TObject;
-
-                template<typename T>
-                void create(TObject &obj) const {
-                    obj = new T{};
-                }
-
-                void destroy(TObject &obj) const {
-                    delete obj;
-                    obj = nullptr;
-                }
-
-                const TPointer getPtr(const TObject &obj) const {
-                    return obj;
-                }
-
-                TPointer getPtr(TObject &obj) const {
-                    return obj;
-                }
-
-            };
-
-            template <typename TObject>
-            struct RawPointerManagerConfig {
-                using RTTI = bitsery::ext::utils::StandardRTTI;
-                static constexpr PointerOwnershipType OwnershipType = PointerOwnershipType::Owner;
-
-                using Handler = RawPointerObjectHandler<TObject>;
-
-                static std::unique_ptr<utils::PointerSharedContextBase> createSharedContext(TObject &) {
-                    return {};
-                }
-
-                static void restoreFromSharedContext(TObject &, utils::PointerSharedContextBase *) {
-
-                }
-            };
-        }
-
-        class PointerOwner : public utils::PointerOwnerManager<details_pointer::RawPointerManagerConfig> {
-        public:
-            explicit PointerOwner(PointerType ptrType = PointerType::Nullable) : PointerOwnerManager(ptrType) {}
-        };
-
-        class PointerObserver {
-        public:
-
-            explicit PointerObserver(PointerType ptrType = PointerType::Nullable) : _ptrType{ptrType} {}
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&) const {
-                auto &ctx = details_pointer::getLinkingContext(ser);
-                if (obj) {
-                    details::writeSize(w, ctx.getInfoByPtr(obj, PointerOwnershipType::Observer).id);
-                } else {
-                    assert(_ptrType == PointerType::Nullable);
-                    details::writeSize(w, 0);
-                }
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &r, T &obj, Fnc &&) const {
-                size_t id{};
-                details::readSize(r, id, std::numeric_limits<size_t>::max());
-                if (id) {
-                    auto &ctx = details_pointer::getLinkingContext(des);
-                    ctx.getInfoById(id, PointerOwnershipType::Observer).processObserver(reinterpret_cast<void *&>(obj));
-                } else {
-                    if (_ptrType == PointerType::Nullable)
-                        obj = nullptr;
-                    else
-                        r.setError(ReaderError::InvalidPointer);
-                }
-            }
-
-        private:
-            PointerType _ptrType;
-        };
-
-        class ReferencedByPointer {
-        public:
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&fnc) const {
-                auto &ctx = details_pointer::getLinkingContext(ser);
-                details::writeSize(w, ctx.getInfoByPtr(&obj, PointerOwnershipType::Owner).id);
-                fnc(const_cast<T &>(obj));
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &r, T &obj, Fnc &&fnc) const {
-                size_t id{};
-                details::readSize(r, id, std::numeric_limits<size_t>::max());
-                if (id) {
-                    auto &ctx = details_pointer::getLinkingContext(des);
-                    fnc(obj);
-                    ctx.getInfoById(id, PointerOwnershipType::Owner).processOwner(&obj);
-                } else {
-                    //cannot be null for references
-                    r.setError(ReaderError::InvalidPointer);
-                }
-            }
-        };
-
-    }
-
-    namespace traits {
-
-        template<typename T>
-        struct ExtensionTraits<ext::PointerOwner, T *> {
-            using TValue = T;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            //pointers cannot have lamba overload, when polymorphism support will be added
-            static constexpr bool SupportLambdaOverload = false;
-        };
-
-        template<typename T>
-        struct ExtensionTraits<ext::PointerObserver, T *> {
-            //although pointer observer doesn't serialize anything, but we still add value overload support to be consistent with pointer owners
-            using TValue = T;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            //pointers cannot have lamba overload, when polymorphism support will be added
-            static constexpr bool SupportLambdaOverload = false;
-        };
-
-        template<typename T>
-        struct ExtensionTraits<ext::ReferencedByPointer, T> {
-            //allow everything, because it is serialized as regular type, except it also creates pointerId that is required by NonOwningPointer to work
-            using TValue = T;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_POINTER_H

include/bitsery/ext/std_map.h

@@ -1,84 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_STD_MAP_H
-#define BITSERY_EXT_STD_MAP_H
-
-#include "../traits/core/traits.h"
-#include "../details/adapter_utils.h"
-
-namespace bitsery {
-    namespace ext {
-
-        class StdMap {
-        public:
-
-            constexpr explicit StdMap(size_t maxSize):_maxSize{maxSize} {}
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &obj, Fnc &&fnc) const {
-                using TKey = typename T::key_type;
-                using TValue = typename T::mapped_type;
-                auto size = obj.size();
-                assert(size <= _maxSize);
-                details::writeSize(writer, size);
-
-                for (auto &v:obj)
-                    fnc(const_cast<TKey &>(v.first), const_cast<TValue &>(v.second));
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &obj, Fnc &&fnc) const {
-                using TKey = typename T::key_type;
-                using TValue = typename T::mapped_type;
-
-                size_t size{};
-                details::readSize(reader, size, _maxSize);
-                auto hint = obj.begin();
-                obj.clear();
-
-                for (auto i = 0u; i < size; ++i) {
-                    TKey key;
-                    TValue value;
-                    fnc(key, value);
-                    hint = obj.emplace_hint(hint, std::move(key), std::move(value));
-                }
-            }
-        private:
-            size_t _maxSize;
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::StdMap, T> {
-            using TValue = void;
-            static constexpr bool SupportValueOverload = false;
-            static constexpr bool SupportObjectOverload = false;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_STD_MAP_H

include/bitsery/ext/std_optional.h

@@ -1,104 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_EXT_STD_OPTIONAL_H
-#define BITSERY_EXT_STD_OPTIONAL_H
-
-
-//this module do not include optional, but expects it to be declared in std::optional
-//if you're using experimental optional from <experimental/optional>
-//add it in std namespace like this:
-//namespace std {
-//    template <typename T>
-//    using optional = experimental::optional<T>;
-//}
-#include <type_traits>
-#include "../traits/core/traits.h"
-
-namespace bitsery {
-    namespace ext {
-
-        template<typename T>
-        using std_optional = ::std::optional<T>;
-
-        class StdOptional {
-        public:
-
-            /**
-             * Works with std::optional types
-             * @param alignBeforeData only makes sense when bit-packing enabled, by default aligns after writing/reading bool state of optional
-             */
-            explicit StdOptional(bool alignBeforeData=true):_alignBeforeData{alignBeforeData} {}
-            template<typename T>
-            constexpr void assertType() const {
-                using TOpt = typename std::remove_cv<T>::type;
-                using TVal = typename TOpt::value_type;
-                static_assert(std::is_same<TOpt, std_optional<TVal>>(), "");
-                static_assert(std::is_default_constructible<TVal>::value, "");
-            };
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
-                assertType<T>();
-                ser.boolValue(static_cast<bool>(obj));
-                if (_alignBeforeData)
-                    ser.align();
-                if (obj)
-                    fnc(const_cast<typename T::value_type & >(*obj));
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
-                assertType<T>();
-                bool exists{};
-                des.boolValue(exists);
-                if (_alignBeforeData)
-                    des.align();
-                if (exists) {
-                    typename T::value_type tmp{};
-                    fnc(tmp);
-                    obj = tmp;
-                } else {
-                    //experimental optional doesnt have .reset method
-                    obj = T{};
-                }
-            }
-        private:
-            bool _alignBeforeData;
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::StdOptional, T> {
-            using TValue = typename T::value_type;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_STD_OPTIONAL_H

include/bitsery/ext/std_queue.h

@@ -1,111 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_EXT_STD_QUEUE_H
-#define BITSERY_EXT_STD_QUEUE_H
-
-#include <type_traits>
-#include <queue>
-//include type traits for deque and vector, because they are defaults for queue and priority_queue
-#include "../traits/deque.h"
-#include "../traits/vector.h"
-
-namespace bitsery {
-    namespace ext {
-
-        class StdQueue {
-        private:
-            //inherit from queue so we could take underlying container
-            template <typename T, typename C>
-            struct QueueCnt : public std::queue<T, C>
-            {
-                static const C& getContainer(const std::queue<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&QueueCnt::c);
-                }
-                static C& getContainer(std::queue<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&QueueCnt::c);
-                }
-            };
-            //inherit from queue so we could take underlying container
-            template <typename T, typename C>
-            struct PriorityQueueCnt : public std::priority_queue<T, C>
-            {
-                static const C& getContainer(const std::priority_queue<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&PriorityQueueCnt::c);
-                }
-                static C& getContainer(std::priority_queue<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&PriorityQueueCnt::c);
-                }
-            };
-
-            size_t _maxSize;
-        public:
-            explicit StdQueue(size_t maxSize):_maxSize{maxSize} {};
-
-            //for queue
-            template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::queue<T,C> &obj, Fnc &&fnc) const {
-                ser.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-            template<typename Des, typename Reader, typename T, typename C, typename Fnc>
-            void deserialize(Des &des, Reader &, std::queue<T,C> &obj, Fnc &&fnc) const {
-                des.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-            //for priority_queue
-            template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::priority_queue<T,C> &obj, Fnc &&fnc) const {
-                ser.container(PriorityQueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-            template<typename Des, typename Reader, typename T, typename C, typename Fnc>
-            void deserialize(Des &des, Reader &, std::priority_queue<T,C> &obj, Fnc &&fnc) const {
-                des.container(PriorityQueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::StdQueue, T> {
-            using TValue = typename T::value_type;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_STD_QUEUE_H

include/bitsery/ext/std_set.h

@@ -1,98 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_STD_SET_H
-#define BITSERY_EXT_STD_SET_H
-
-#include <cassert>
-#include "../details/adapter_utils.h"
-//we need this, so we could
-#include <unordered_set>
-#include "../traits/core/traits.h"
-
-namespace bitsery {
-    namespace ext {
-
-        class StdSet {
-        public:
-
-            constexpr explicit StdSet(size_t maxSize):_maxSize{maxSize} {}
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &obj, Fnc &&fnc) const {
-                using TKey = typename T::key_type;
-                auto size = obj.size();
-                assert(size <= _maxSize);
-                details::writeSize(writer, size);
-
-                for (auto &v:obj)
-                    fnc(const_cast<TKey &>(v));
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &obj, Fnc &&fnc) const {
-                using TKey = typename T::key_type;
-
-                size_t size{};
-                details::readSize(reader, size, _maxSize);
-                auto hint = obj.begin();
-                obj.clear();
-                reserve(obj, size);
-
-                for (auto i = 0u; i < size; ++i) {
-                    TKey key;
-                    fnc(key);
-                    hint = obj.emplace_hint(hint, std::move(key));
-                }
-            }
-        private:
-
-            template <typename T>
-            void reserve(std::unordered_set<T>& obj, size_t size) const {
-                obj.reserve(size);
-            }
-            template <typename T>
-            void reserve(std::unordered_multiset<T>& obj, size_t size) const {
-                obj.reserve(size);
-            }
-            template <typename T>
-            void reserve(T& , size_t ) const {
-                //for ordered container do nothing
-            }
-            size_t _maxSize;
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::StdSet, T> {
-            using TValue = typename T::key_type;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_STD_SET_H

include/bitsery/ext/std_stack.h

@@ -1,82 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_EXT_STD_STACK_H
-#define BITSERY_EXT_STD_STACK_H
-
-#include <type_traits>
-#include <stack>
-//include type traits for deque, because stack default underlying container is deque
-#include "../traits/deque.h"
-
-namespace bitsery {
-    namespace ext {
-
-        class StdStack {
-        private:
-            //inherit from stack so we could take underlying container
-            template <typename T, typename C>
-            struct StackCnt : public std::stack<T, C>
-            {
-                static const C& getContainer(const std::stack<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&StackCnt::c);
-                }
-                static C& getContainer(std::stack<T, C>& s )
-                {
-                    //get address of underlying container
-                    return s.*(&StackCnt::c);
-                }
-            };
-            size_t _maxSize;
-        public:
-            explicit StdStack(size_t maxSize):_maxSize{maxSize} {};
-
-            template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::stack<T,C> &obj, Fnc &&fnc) const {
-                ser.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-            template<typename Des, typename Reader, typename T, typename C, typename Fnc>
-            void deserialize(Des &des, Reader &, std::stack<T,C> &obj, Fnc &&fnc) const {
-                des.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
-            }
-
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::StdStack, T> {
-            using TValue = typename T::value_type;
-            static constexpr bool SupportValueOverload = true;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = true;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_STD_STACK_H

include/bitsery/ext/utils/pointer_utils.h

@@ -1,319 +0,0 @@
-//
-// Created by fraillt on 17.11.30.
-//
-
-#ifndef BITSERY_POINTER_UTILS_H
-#define BITSERY_POINTER_UTILS_H
-
-#include <unordered_map>
-#include <vector>
-#include <memory>
-
-#include "polymorphism_utils.h"
-
-namespace bitsery {
-    namespace ext {
-
-        enum class PointerType {
-            Nullable,
-            NotNull
-        };
-
-        enum class PointerOwnershipType : uint8_t {
-            //is not responsible for pointer lifetime management.
-                    Observer,
-            //only ONE owner is responsible for this pointers creation/destruction
-                    Owner,
-            //MANY shared owners is responsible for pointer creation/destruction
-            //requires additional context to manage shared owners themselves.
-                    Shared
-        };
-
-        //forward declaration
-        class PointerLinkingContext;
-
-        namespace utils {
-            class PointerLinkingContextSerialization {
-            public:
-                explicit PointerLinkingContextSerialization()
-                        : _currId{0},
-                          _ptrMap{} {}
-
-                PointerLinkingContextSerialization(const PointerLinkingContextSerialization &) = delete;
-
-                PointerLinkingContextSerialization &operator=(const PointerLinkingContextSerialization &) = delete;
-
-                PointerLinkingContextSerialization(PointerLinkingContextSerialization &&) = default;
-
-                PointerLinkingContextSerialization &operator=(PointerLinkingContextSerialization &&) = default;
-
-                ~PointerLinkingContextSerialization() = default;
-
-                struct PointerInfo {
-                    PointerInfo(size_t id_, PointerOwnershipType ownershipType_)
-                            : id{id_},
-                              ownershipType{ownershipType_},
-                              sharedCount{0} {};
-                    size_t id;
-                    PointerOwnershipType ownershipType;
-                    size_t sharedCount;
-                };
-
-                const PointerInfo &getInfoByPtr(const void *ptr, PointerOwnershipType ptrType) {
-                    auto res = _ptrMap.emplace(ptr, PointerInfo{_currId + 1u, ptrType});
-                    auto &ptrInfo = res.first->second;
-                    if (res.second) {
-                        ++_currId;
-                        return ptrInfo;
-                    }
-                    //ptr already exists
-                    //for observer return success
-                    if (ptrType == PointerOwnershipType::Observer)
-                        return ptrInfo;
-                    //set owner and return success
-                    if (ptrInfo.ownershipType == PointerOwnershipType::Observer) {
-                        ptrInfo.ownershipType = ptrType;
-                        return ptrInfo;
-                    }
-                    //only shared ownership can get here multiple times
-                    assert(ptrType == PointerOwnershipType::Shared);
-                    ptrInfo.sharedCount++;
-                    return ptrInfo;
-                }
-
-                //valid, when all pointers have owners.
-                //we cannot serialize pointers, if we haven't serialized objects themselves
-                bool isPointerSerializationValid() const {
-                    return std::all_of(_ptrMap.begin(), _ptrMap.end(),
-                                       [](const std::pair<const void *, PointerInfo> &p) {
-                                           return p.second.ownershipType != PointerOwnershipType::Observer;
-                                       });
-                }
-
-            private:
-                size_t _currId;
-                std::unordered_map<const void *, PointerInfo> _ptrMap;
-
-            };
-
-            //this class is used to store context for shared ptr owners
-            struct PointerSharedContextBase {
-                virtual ~PointerSharedContextBase() = default;
-            };
-
-            class PointerLinkingContextDeserialization {
-            public:
-                explicit PointerLinkingContextDeserialization()
-                        : _idMap{} {}
-
-                PointerLinkingContextDeserialization(const PointerLinkingContextDeserialization &) = delete;
-
-                PointerLinkingContextDeserialization &operator=(const PointerLinkingContextDeserialization &) = delete;
-
-                PointerLinkingContextDeserialization(PointerLinkingContextDeserialization &&) = default;
-
-                PointerLinkingContextDeserialization &operator=(PointerLinkingContextDeserialization &&) = default;
-
-                ~PointerLinkingContextDeserialization() = default;
-
-
-                struct PointerInfo {
-                    PointerInfo(size_t id_, void *ptr, PointerOwnershipType ownershipType_)
-                            : id{id_},
-                              ownershipType{ownershipType_},
-                              ownerPtr{ptr},
-                              observersList{},
-                              sharedContext{} {};
-
-                    PointerInfo(const PointerInfo &) = delete;
-
-                    PointerInfo &operator=(const PointerInfo &) = delete;
-
-                    PointerInfo(PointerInfo &&) = default;
-
-                    PointerInfo &operator=(PointerInfo &&) = default;
-
-                    ~PointerInfo() = default;
-
-                    void processOwner(void *ptr) {
-                        ownerPtr = ptr;
-                        assert(ownershipType != PointerOwnershipType::Observer);
-                        for (auto &o:observersList)
-                            o.get() = ptr;
-                        observersList.clear();
-                        observersList.shrink_to_fit();
-                    }
-
-                    void processObserver(void *(&ptr)) {
-                        if (ownerPtr) {
-                            ptr = ownerPtr;
-                        } else {
-                            observersList.push_back(ptr);
-                        }
-                    }
-
-                    size_t id;
-                    PointerOwnershipType ownershipType;
-                    void *ownerPtr;
-                    std::vector<std::reference_wrapper<void *>> observersList;
-                    std::unique_ptr<PointerSharedContextBase> sharedContext;
-                };
-
-                PointerInfo &getInfoById(size_t id, PointerOwnershipType ptrType) {
-                    auto res = _idMap.emplace(id, PointerInfo{id, nullptr, ptrType});
-                    auto &ptrInfo = res.first->second;
-                    if (!res.second) {
-                        assert(ptrType != PointerOwnershipType::Owner ||
-                               ptrInfo.ownershipType == PointerOwnershipType::Observer);
-                        if (ptrInfo.ownershipType == PointerOwnershipType::Observer)
-                            ptrInfo.ownershipType = ptrType;
-                    }
-                    return ptrInfo;
-                }
-
-                //valid, when all pointers has owners
-                bool isPointerDeserializationValid() const {
-                    return std::all_of(_idMap.begin(), _idMap.end(), [](const std::pair<const size_t, PointerInfo> &p) {
-                        return p.second.ownershipType != PointerOwnershipType::Observer;
-                    });
-                }
-
-            private:
-                std::unordered_map<size_t, PointerInfo> _idMap;
-            };
-
-            template<template<typename> class Config>
-            class PointerOwnerManager {
-
-                template <typename TObject>
-                using Handler = typename Config<TObject>::Handler;
-
-                template<typename TObject>
-                struct HelperTypes {
-                    using RTTI = typename Config<TObject>::RTTI;
-                    using THandler = Handler<TObject>;
-                    using TValue = typename std::remove_pointer<typename THandler::TPointer>::type;
-                };
-
-                template<typename Ser, typename T, typename Fnc>
-                void serializeImpl(PointerLinkingContextSerialization &, Ser &ser, const T &obj, Fnc &&,
-                                   std::true_type) const {
-                    InheritanceTreeSerialize<Ser, T, HelperTypes> tree{};
-                    auto handler = tree.getHandler(obj);
-
-                    assert(handler.second);
-                    ser.object(handler.first);
-                    handler.second->process(ser, const_cast<T &>(obj));
-                }
-
-                template<typename Ser, typename T, typename Fnc>
-                void serializeImpl(PointerLinkingContextSerialization &, Ser &, const T &obj, Fnc &&fnc,
-                                   std::false_type) const {
-                    auto handler = Handler<T>{};
-                    fnc(*handler.getPtr(const_cast<T &>(obj)));
-                }
-
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PointerLinkingContextDeserialization &, Des &des, T &obj, Fnc &&,
-                                     Reader &r, std::true_type) const {
-                    InheritanceTreeTypeId id{};
-                    des.object(id);
-
-                    InheritanceTreeDeserialize<Des, T, HelperTypes> tree{};
-                    auto handler = tree.getHandler(id);
-                    if (handler) {
-                        handler->create(obj);
-                        handler->process(des, obj);
-                    } else {
-                        r.setError(ReaderError::InvalidPointer);
-                    }
-                }
-
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PointerLinkingContextDeserialization &, Des &, T &obj, Fnc &&fnc,
-                                     Reader &, std::false_type) const {
-                    using TValue = typename HelperTypes<T>::TValue;
-                    auto handler = Handler<T>{};
-                    if (auto ptr = handler.getPtr(obj)) {
-                        fnc(*ptr);
-                    } else {
-                        handler.template create<TValue>(obj);
-                        fnc(*handler.getPtr(obj));
-                    }
-                }
-
-                PointerType _ptrType;
-            public:
-
-                explicit PointerOwnerManager(PointerType ptrType = PointerType::Nullable) : _ptrType{ptrType} {}
-
-                template<typename Ser, typename Writer, typename T, typename Fnc>
-                void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&fnc) const {
-                    auto handler = Handler<T>{};
-                    auto ptr = handler.getPtr(obj);
-                    if (ptr) {
-                        auto ctx = ser.template context<PointerLinkingContext>();
-                        assert(ctx != nullptr);
-                        auto &ptrInfo = ctx->getInfoByPtr(ptr, Config<T>::OwnershipType);
-                        details::writeSize(w, ptrInfo.id);
-                        if (ptrInfo.sharedCount == 0) {
-                            serializeImpl(*ctx, ser, obj, std::forward<Fnc>(fnc),
-                                          std::is_polymorphic<typename HelperTypes<T>::TValue>{});
-                        }
-                    } else {
-                        assert(_ptrType == PointerType::Nullable);
-                        details::writeSize(w, 0);
-                    }
-                }
-
-                template<typename Des, typename Reader, typename T, typename Fnc>
-                void deserialize(Des &des, Reader &r, T &obj, Fnc &&fnc) const {
-                    size_t id{};
-                    details::readSize(r, id, std::numeric_limits<size_t>::max());
-                    auto handler = Handler<T>{};
-                    if (id) {
-                        auto ctx = des.template context<PointerLinkingContext>();
-                        assert(ctx != nullptr);
-                        auto &ptrInfo = ctx->getInfoById(id, Config<T>::OwnershipType);
-                        //todo add deserialization checking
-                        if (ptrInfo.ownershipType == PointerOwnershipType::Owner) {
-                            deserializeImpl(*ctx, des, obj, std::forward<Fnc>(fnc), r,
-                                            std::is_polymorphic<typename HelperTypes<T>::TValue>{});
-                            ptrInfo.processOwner(handler.getPtr(obj));
-                        } else {
-                            if (!ptrInfo.sharedContext) {
-                                deserializeImpl(*ctx, des, obj, std::forward<Fnc>(fnc), r,
-                                                std::is_polymorphic<typename HelperTypes<T>::TValue>{});
-                                ptrInfo.processOwner(handler.getPtr(obj));
-                                ptrInfo.sharedContext = Config<T>::createSharedContext(obj);
-                            } else {
-                                Config<T>::restoreFromSharedContext(obj, ptrInfo.sharedContext.get());
-                            }
-                        }
-
-                    } else {
-                        if (_ptrType == PointerType::Nullable && handler.getPtr(obj)) {
-                            handler.destroy(obj);
-                        } else
-                            r.setError(ReaderError::InvalidPointer);
-                    }
-                }
-
-            };
-
-        }
-
-        //this class is for convenience
-        class PointerLinkingContext :
-                public utils::PointerLinkingContextSerialization,
-                public utils::PointerLinkingContextDeserialization {
-        public:
-            bool isValid() {
-                return isPointerSerializationValid() && isPointerDeserializationValid();
-            }
-        };
-
-    }
-}
-
-#endif //BITSERY_POINTER_UTILS_H

include/bitsery/ext/utils/polymorphism_utils.h

@@ -1,225 +0,0 @@
-//
-// Created by fraillt on 17.11.3.
-//
-
-#ifndef BITSERY_EXT_POLYMORPHISM_H
-#define BITSERY_EXT_POLYMORPHISM_H
-
-#include "../inheritance.h"
-
-#include <unordered_map>
-#include <functional>
-#include <memory>
-
-namespace bitsery {
-
-    namespace ext {
-        namespace details_polymorphism {
-            //stores template types
-            template<typename ...>
-            struct List {
-            };
-        }
-
-        //specialize for your base class by deriving from DerivedClasses with list of derivatives that DIRECTLY inherits from your base class.
-//e.g.
-// template <> PolymorphicBase<Animal>: DerivedClasses<Dog, Cat>{};
-// template <> PolymorphicBase<Dog>: DerivedClasses<Bulldog, GoldenRetriever> {};
-// IMPORTANT !!!
-// although you can add all derivates to same base like this:
-// SuperClass<Animal>:DerivedClasses<Dog, Cat, Bulldog, GoldenRetriever>{};
-// it will not work when you try to serialize Dog*, because it will not find Bulldog and GoldenRetriever
-        template<typename TBase>
-        struct PolymorphicBaseClass {
-            using childs = details_polymorphism::List<>;
-        };
-
-//derive from this class when specifying childs for your base class, atleast one child must exists, hence T1
-//e.g.
-// template <> SuperClass<Animal>: DerivedClasses<Dog, Cat>{};
-        template<typename T1, typename ... Tn>
-        struct DerivedClasses {
-            using childs = details_polymorphism::List<T1, Tn...>;
-        };
-
-        namespace utils {
-            //this object will be used to serialize/deserialize polymorphic type id within inheritance tree from base class
-            struct InheritanceTreeTypeId {
-                uint16_t depth{};
-                uint16_t index{};
-                template <typename S>
-                void serialize(S& s) {
-                    s.value2b(depth);
-                    s.value2b(index);
-                }
-            };
-
-            template <typename S, typename TObject>
-            struct PolymorphicObjectHandlerInterface {
-                virtual void process(S& s, TObject& obj) const = 0;
-                virtual void create(TObject& obj) const = 0;
-                virtual ~PolymorphicObjectHandlerInterface() = default;
-            };
-        }
-
-        namespace details_polymorphism {
-
-
-            template<typename S, typename TObject, typename TDerived, typename RTTI, typename ObjectHandler>
-            struct PolymorphicObjectHandlerBase : public utils::PolymorphicObjectHandlerInterface<S, TObject> {
-                void process(S &s, TObject &obj) const final {
-                    s.object(dynamic_cast<TDerived &>(*_handler.getPtr(obj)));
-                };
-
-                void create(TObject &obj) const final {
-                    auto ptr = _handler.getPtr(obj);
-                    if (ptr && RTTI::get(*ptr) != RTTI::template get<TDerived>()) {
-                        _handler.destroy(obj);
-                        _handler.template create<TDerived>(obj);
-                    } else {
-                        if (ptr == nullptr)
-                            _handler.template create<TDerived>(obj);
-                    }
-                }
-                ObjectHandler _handler{};
-            };
-
-            template<typename S, typename TObject, template<typename> class TObjectManager>
-            class PolymorphicHandlersGenerator {
-            public:
-                template<typename Fnc>
-                static void generate(Fnc &&addHandlerFnc) {
-                    PolymorphicHandlersGenerator tmp{std::forward<Fnc>(addHandlerFnc)};
-                }
-
-            private:
-                using RTTI = typename TObjectManager<TObject>::RTTI;
-
-                template <typename TDerived>
-                using TPolymorphicObjectHandler = PolymorphicObjectHandlerBase<S, TObject, TDerived, RTTI, typename TObjectManager<TObject>::THandler>;
-
-                template<typename Fnc>
-                explicit PolymorphicHandlersGenerator(Fnc &&addHandlerFnc):_addHandler(std::forward<Fnc>(addHandlerFnc)) {
-                    //fill inheritance tree
-                    using TBase = typename TObjectManager<TObject>::TValue;
-                    add<TBase>();
-                }
-
-                template<typename TClass>
-                void add() {
-                    addClass<TClass>();
-                    //save current index and increase depth
-                    auto saveIndex = index;
-                    index = 0;
-                    depth++;
-                    addChilds<TClass>(typename PolymorphicBaseClass<TClass>::childs{});
-                    //restore index and depth
-                    depth--;
-                    index = saveIndex;
-                }
-
-                template<typename TClassBase, typename T1, typename ... Tn>
-                void addChilds(details_polymorphism::List<T1, Tn...>) {
-                    static_assert(std::is_base_of<TClassBase, T1>::value,
-                                  "PolymorphicBaseClass<TBase> must derive a list of derived classes from TBase.");
-                    add<T1>();
-                    addChilds<TClassBase>(details_polymorphism::List<Tn...>{});
-                }
-
-                template<typename>
-                void addChilds(details_polymorphism::List<>) {
-                }
-
-
-                template<typename TClass>
-                void addClass() {
-                    if (!std::is_abstract<TClass>::value) {
-                        utils::InheritanceTreeTypeId tid{};
-                        tid.index = index;
-                        tid.depth = depth;
-#if __cplusplus > 201103L
-                        auto handler = std::make_unique<TPolymorphicObjectHandler<TClass>>();
-#else
-                        auto handler = std::unique_ptr<TPolymorphicObjectHandler<TClass>>(
-                                new TPolymorphicObjectHandler<TClass>{});
-#endif
-                        if (_addHandler(RTTI::template get<TClass>(), tid, std::move(handler)))
-                            ++index;
-                    }
-                }
-
-                std::function<bool(size_t, utils::InheritanceTreeTypeId,
-                                   std::unique_ptr<utils::PolymorphicObjectHandlerInterface<S, TObject>> &&)> _addHandler;
-                uint16_t depth{};
-                uint16_t index{};
-            };
-
-        }
-
-        namespace utils {
-
-            template<typename Ser, typename TObject, template<typename> class TObjectManager>
-            class InheritanceTreeSerialize {
-            public:
-
-                InheritanceTreeSerialize() {
-                    details_polymorphism::PolymorphicHandlersGenerator<Ser, TObject, TObjectManager>::generate(
-                            [this](size_t typeHash, InheritanceTreeTypeId id,
-                                   std::unique_ptr<PolymorphicObjectHandlerInterface<Ser, TObject>> &&handler) {
-                                return _map.emplace(std::make_pair(typeHash, std::make_pair(id, std::move(handler)))).second;
-                            }
-                    );
-
-                }
-
-                const std::pair<InheritanceTreeTypeId, PolymorphicObjectHandlerInterface<Ser, TObject>*> getHandler(const TObject &obj) {
-                    using RTTI = typename TObjectManager<TObject>::RTTI;
-                    auto handler = typename TObjectManager<TObject>::THandler{};
-                    auto it = _map.find(RTTI::get(*handler.getPtr(obj)));
-                    if (it != _map.end()) {
-                        return std::make_pair(it->second.first, it->second.second.get());
-                    }
-                    return {};
-                }
-
-            private:
-                std::unordered_map<size_t, std::pair<InheritanceTreeTypeId, std::unique_ptr<PolymorphicObjectHandlerInterface<Ser, TObject>>>> _map{};
-            };
-
-
-            template<typename Des, typename TObject, template<typename> class TObjectManager>
-            class InheritanceTreeDeserialize {
-            public:
-                InheritanceTreeDeserialize() {
-                    details_polymorphism::PolymorphicHandlersGenerator<Des, TObject, TObjectManager>::generate(
-                            [this](size_t, InheritanceTreeTypeId id, std::unique_ptr<PolymorphicObjectHandlerInterface<Des, TObject>> &&handler) {
-                                return _map.emplace(std::make_pair(getHashFromId(id), std::move(handler))).second;
-                            }
-                    );
-                }
-
-                const PolymorphicObjectHandlerInterface<Des, TObject> *getHandler(const InheritanceTreeTypeId &id) {
-                    auto it = _map.find(getHashFromId(id));
-                    if (it != _map.end())
-                        return it->second.get();
-                    return nullptr;
-                }
-
-            private:
-                size_t getHashFromId(const InheritanceTreeTypeId &id) const {
-                    size_t res = id.depth << 16;
-                    return res + id.index;
-                }
-
-                std::unordered_map<size_t, std::unique_ptr<PolymorphicObjectHandlerInterface<Des, TObject>>> _map{};
-            };
-
-
-        }
-
-
-    }
-
-}
-
-#endif //BITSERY_EXT_POLYMORPHISM_H

include/bitsery/ext/utils/rtti_utils.h

@@ -1,28 +0,0 @@
-//
-// Created by fraillt on 17.11.30.
-//
-
-#ifndef BITSERY_RTTI_UTILS_H
-#define BITSERY_RTTI_UTILS_H
-
-#include <typeinfo>
-
-namespace bitsery {
-    namespace ext {
-        namespace utils {
-            struct StandardRTTI {
-                template<typename T>
-                static size_t get() {
-                    return typeid(T).hash_code();
-                }
-
-                template<typename T>
-                static size_t get(T &&obj) {
-                    return typeid(obj).hash_code();
-                }
-            };
-        }
-    }
-}
-
-#endif //BITSERY_RTTI_UTILS_H

include/bitsery/ext/value_range.h

@@ -1,206 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_EXT_VALUE_RANGE_H
-#define BITSERY_EXT_VALUE_RANGE_H
-
-#include "../details/serialization_common.h"
-#include "../details/adapter_common.h"
-#include <cassert>
-
-namespace bitsery {
-
-    namespace ext {
-        //this class is used to make default RangeSpec float specialization always prefer constructor with precision
-        struct BitsConstraint {
-            explicit constexpr BitsConstraint(size_t bits) : value{bits} {}
-
-            const size_t value;
-        };
-    }
-
-    //implementation details for range functionality
-    namespace details {
-
-        template<typename T>
-        constexpr size_t getSize(T v, size_t s) {
-            return v > 0 ? getSize(v / 2, s + 1) : s;
-        }
-
-        template<typename T>
-        constexpr size_t calcRequiredBits(T min, T max) {
-            //call recursive function, because some compilers only support constexpr functions with return-only body
-            return getSize(max - min, 0);
-        }
-
-        template<typename T, typename Enable = void>
-        struct RangeSpec {
-
-            constexpr RangeSpec(T minValue, T maxValue)
-                    : min{minValue},
-                      max{maxValue},
-                      bitsRequired{calcRequiredBits(min, max)} {
-            }
-
-            const T min;
-            const T max;
-            const size_t bitsRequired;
-        };
-
-
-        template<typename T>
-        struct RangeSpec<T, typename std::enable_if<std::is_enum<T>::value>::type> {
-
-            constexpr RangeSpec(T minValue, T maxValue) :
-                    min{minValue},
-                    max{maxValue},
-                    bitsRequired{calcRequiredBits(
-                            static_cast<typename std::underlying_type<T>::type>(min),
-                            static_cast<typename std::underlying_type<T>::type>(max))} {
-            }
-
-            const T min;
-            const T max;
-            const size_t bitsRequired;
-        };
-
-
-        template<typename T>
-        struct RangeSpec<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-
-            constexpr RangeSpec(T minValue, T maxValue, ext::BitsConstraint bits) :
-                    min{minValue},
-                    max{maxValue},
-                    bitsRequired{bits.value} {
-            }
-
-            constexpr RangeSpec(T minValue, T maxValue, T precision) :
-                    min{minValue},
-                    max{maxValue},
-                    bitsRequired{calcRequiredBits<details::SameSizeUnsigned<T>>({}, ((max - min) / precision))} {
-
-            }
-
-            const T min;
-            const T max;
-            const size_t bitsRequired;
-        };
-
-        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
-        details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
-            return static_cast<details::SameSizeUnsigned<T>>(v - r.min);
-        }
-
-        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-        details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
-            using VT = details::SameSizeUnsigned<T>;
-            return static_cast<VT>(static_cast<VT>(v) - static_cast<VT>(r.min));
-        }
-
-        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
-        details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
-            using VT = details::SameSizeUnsigned<T>;
-            const VT maxUint = (static_cast<VT>(1) << r.bitsRequired) - 1;
-            const auto ratio = (v - r.min) / (r.max - r.min);
-            return static_cast<VT>(ratio * maxUint);
-        }
-
-        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
-        void setRangeValue(T &v, const RangeSpec<T> &r) {
-            v += r.min;
-        }
-
-        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-        void setRangeValue(T &v, const RangeSpec<T> &r) {
-            using VT = typename std::underlying_type<T>::type;
-            reinterpret_cast<VT &>(v) += static_cast<VT>(r.min);
-        }
-
-        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
-        void setRangeValue(T &v, const RangeSpec<T> &r) {
-            using UIT = details::SameSizeUnsigned<T>;
-            const auto intRep = reinterpret_cast<UIT &>(v);
-            const UIT maxUint = (static_cast<UIT>(1) << r.bitsRequired) - 1;
-            v = r.min + (static_cast<T>(intRep) / maxUint) * (r.max - r.min);
-        }
-
-        template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type * = nullptr>
-        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
-            return !(r.min > v || v > r.max);
-        }
-
-        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
-            using VT = typename std::underlying_type<T>::type;
-            return !(static_cast<VT>(r.min) > static_cast<VT>(v)
-                     || static_cast<VT>(v) > static_cast<VT>(r.max));
-        }
-    }
-
-    namespace ext {
-
-        template<typename TValue>
-        class ValueRange {
-        public:
-
-            template<typename ... Args>
-            explicit constexpr ValueRange(Args &&... args):_range{std::forward<Args>(args)...} {}
-
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &v, Fnc &&) const {
-                assert(details::isRangeValid(v, _range));
-                using BT = decltype(details::getRangeValue(v, _range));
-                writer.template writeBits<BT>(details::getRangeValue(v, _range), _range.bitsRequired);
-            }
-
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &v, Fnc &&) const {
-                reader.readBits(reinterpret_cast<details::SameSizeUnsigned<T> &>(v), _range.bitsRequired);
-                details::setRangeValue(v, _range);
-                if (!details::isRangeValid(v, _range)) {
-                    reader.setError(ReaderError::InvalidData);
-                    v = _range.min;
-                }
-            }
-
-            constexpr size_t getRequiredBits() const {
-                return _range.bitsRequired;
-            };
-        private:
-            details::RangeSpec<TValue> _range;
-        };
-    }
-
-    namespace traits {
-        template<typename T>
-        struct ExtensionTraits<ext::ValueRange<T>, T> {
-            using TValue = void;
-            static constexpr bool SupportValueOverload = false;
-            static constexpr bool SupportObjectOverload = true;
-            static constexpr bool SupportLambdaOverload = false;
-        };
-    }
-
-}
-
-
-#endif //BITSERY_EXT_VALUE_RANGE_H

include/bitsery/flexible.h

@@ -1,110 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_H
-#define BITSERY_FLEXIBLE_H
-
-#include "details/serialization_common.h"
-#include "details/flexible_common.h"
-
-namespace bitsery {
-
-    namespace flexible {
-
-        //overload when T is reference type
-        template<typename S, typename T>
-        void archiveProcessImpl(S &s, T &&head, std::true_type) {
-            s.object(std::forward<T>(head));
-        }
-
-        //overload when T is rvalue type, only allowable for behaviour modifying functions for deserializer
-        template<typename S, typename T>
-        void archiveProcessImpl(S &s, T &&head, std::false_type) {
-            static_assert(std::is_base_of<ArchiveWrapperFnc, T>::value,
-                          "\nOnly archive behaviour modifying functions can be passed by rvalue to deserializer\n");
-            serialize(s, head);
-        }
-
-    }
-
-    //define function that enables s.archive(....) usage
-    template<typename S, typename T>
-    void archiveProcess(S &s, T &&head) {
-        flexible::archiveProcessImpl(s, std::forward<T>(head), std::is_reference<T>{});
-    }
-
-    //wrapper functions that enables to serialize as container or string
-    template<typename T, size_t N>
-    flexible::CArray<T, N, true> asText(T (&str)[N]) {
-        return {str};
-    }
-
-    template<typename T, size_t N>
-    flexible::CArray<T, N, false> asContainer(T (&obj)[N]) {
-        return {obj};
-    }
-
-    template <typename T>
-    flexible::MaxSize<T> maxSize(T& obj, size_t max) {
-        return {obj, max};
-    }
-
-//define serialize function for fundamental types
-    template<typename S>
-    void serialize(S &s, bool &v) {
-        s.boolValue(v);
-    }
-
-    template<typename S, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
-    void serialize(S &s, T &v) {
-        s.template value<sizeof(T)>(v);
-    }
-
-//define serialization for c-style container
-
-    //if array is integral type, specify explicitly how to process: as text or container
-    template<typename S, typename T, size_t N, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
-    void serialize(S &, T (&)[N]) {
-        static_assert(N == 0,
-                      "\nPlease use 'asText(obj)' or 'asContainer(obj)' when using c-style array with integral types\n");
-    }
-
-    template<typename S, typename T, size_t N, typename std::enable_if<!std::is_integral<T>::value>::type * = nullptr>
-    void serialize(S &s, T (&obj)[N]) {
-        flexible::processContainer(s, obj);
-    }
-
-    //this is a helper class that enforce fundamental type sizes, when used on multiple platforms
-    template <size_t TShort, size_t TInt, size_t TLong, size_t TLongLong>
-    void assertFundamentalTypeSizes() {
-        //http://en.cppreference.com/w/cpp/language/types
-        static_assert(sizeof(short) == TShort, "");
-        static_assert(sizeof(int) == TInt, "");
-        static_assert(sizeof(long) == TLong, "");
-        static_assert(sizeof(long long) == TLongLong, "");
-        //for completion we also need pointer type size, but serializer doesn't support pointer serialization.
-    }
-
-}
-
-#endif //BITSERY_FLEXIBLE_H

include/bitsery/flexible/array.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H
-#define BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H
-
-#include "../traits/array.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename T, size_t N>
-    void serialize(S &s, std::array<T, N> &obj) {
-        flexible::processContainer(s, obj);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H

include/bitsery/flexible/deque.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H
-#define BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H
-
-#include "../traits/deque.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::deque<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H

include/bitsery/flexible/forward_list.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H
-#define BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H
-
-#include "../traits/forward_list.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::forward_list<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H

include/bitsery/flexible/list.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_LIST_H
-#define BITSERY_FLEXIBLE_TYPE_STD_LIST_H
-
-#include "../traits/list.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::list<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_LIST_H

include/bitsery/flexible/map.h

@@ -1,54 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_MAP_H
-#define BITSERY_FLEXIBLE_TYPE_STD_MAP_H
-
-#include <map>
-#include "../ext/std_map.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::map<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        using TKey = typename std::map<TArgs...>::key_type;
-        using TValue = typename std::map<TArgs...>::mapped_type;
-        s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
-                  s.object(key);
-                  s.object(value);
-              });
-    }
-
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::multimap<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        using TKey = typename std::multimap<TArgs...>::key_type;
-        using TValue = typename std::multimap<TArgs...>::mapped_type;
-        s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
-                  s.object(key);
-                  s.object(value);
-              });
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_MAP_H

include/bitsery/flexible/queue.h

@@ -1,42 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H
-#define BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H
-
-#include "../ext/std_queue.h"
-
-namespace bitsery {
-    template<typename S, typename T, typename C>
-    void serialize(S &s, std::queue<T, C> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdQueue{maxSize});
-    }
-
-    template<typename S, typename T, typename C, typename Comp>
-    void serialize(S &s, std::priority_queue<T, C, Comp> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdQueue{maxSize});
-    }
-
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H

include/bitsery/flexible/set.h

@@ -1,43 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_SET_H
-#define BITSERY_FLEXIBLE_TYPE_STD_SET_H
-
-#include <set>
-#include "../ext/std_set.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::set<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdSet{maxSize});
-    }
-
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::multiset<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdSet{maxSize});
-    }
-
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_SET_H

include/bitsery/flexible/stack.h

@@ -1,36 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_STACK_H
-#define BITSERY_FLEXIBLE_TYPE_STD_STACK_H
-
-#include "../ext/std_stack.h"
-
-namespace bitsery {
-    template<typename S, typename T, typename C>
-    void serialize(S &s, std::stack<T, C> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdStack{maxSize});
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_STACK_H

include/bitsery/flexible/string.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_STRING_H
-#define BITSERY_FLEXIBLE_TYPE_STD_STRING_H
-
-#include "../traits/string.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename T, typename ... TArgs>
-    void serialize(S &s, std::basic_string<T, TArgs...> &str) {
-        flexible::processContainer(s, str);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_STRING_H

include/bitsery/flexible/unordered_map.h

@@ -1,55 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H
-#define BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H
-
-#include <unordered_map>
-#include "../ext/std_map.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::unordered_map<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        using TKey = typename std::unordered_map<TArgs...>::key_type;
-        using TValue = typename std::unordered_map<TArgs...>::mapped_type;
-        s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
-                  s.object(key);
-                  s.object(value);
-              });
-    }
-
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::unordered_multimap<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        using TKey = typename std::unordered_multimap<TArgs...>::key_type;
-        using TValue = typename std::unordered_multimap<TArgs...>::mapped_type;
-        s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
-                  s.object(key);
-                  s.object(value);
-              });
-    }
-
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H

include/bitsery/flexible/unordered_set.h

@@ -1,43 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H
-#define BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H
-
-#include <unordered_set>
-#include "../ext/std_set.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::unordered_set<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdSet{maxSize});
-    }
-
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::unordered_multiset<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
-        s.ext(obj, ext::StdSet{maxSize});
-    }
-
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H

include/bitsery/flexible/vector.h

@@ -1,37 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H
-#define BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H
-
-#include "../traits/vector.h"
-#include "../details/flexible_common.h"
-
-namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::vector<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
-    }
-}
-
-#endif //BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H

include/bitsery/serializer.h

@@ -21,423 +21,310 @@
 //SOFTWARE.
 
 
+
 #ifndef BITSERY_SERIALIZER_H
 #define BITSERY_SERIALIZER_H
 
+#include "common.h"
+#include <array>
 #include "details/serialization_common.h"
-#include "adapter_writer.h"
-#include <cassert>
 
 namespace bitsery {
 
-    template<typename TAdapterWriter, typename TContext = void>
-    class BasicSerializer {
+    template<typename Writter>
+    class Serializer {
     public:
-        //this is used by AdapterAccess class
-        using TWriter = TAdapterWriter;
-        //helper type, that always returns bit-packing enabled type, useful inside serialize function when enabling bitpacking
-        using BPEnabledType = BasicSerializer<typename std::conditional<TAdapterWriter::BitPackingEnabled,
-                TAdapterWriter, AdapterWriterBitPackingWrapper<TAdapterWriter>>::type, TContext>;
+        Serializer(Writter &w) : _writter{w} {};
 
-        static_assert(details::IsSpecializationOf<typename TWriter::TConfig::InternalContext, std::tuple>::value,
-                      "Config::InternalContext must be std::tuple");
-
-        template <typename WriterParam>
-        explicit BasicSerializer(WriterParam&& w, TContext* context = nullptr)
-                : _writer{std::forward<WriterParam>(w)},
-                  _context{context},
-                  _internalContext{}
-        {
-        }
-
-        //copying disabled
-        BasicSerializer(const BasicSerializer&) = delete;
-        BasicSerializer& operator = (const BasicSerializer&) = delete;
-
-        //move enabled
-        BasicSerializer(BasicSerializer&& ) = default;
-        BasicSerializer& operator = (BasicSerializer&& ) = default;
-
-        /*
-         * get serialization context.
-         * this is optional, but might be required for some specific serialization flows.
-         */
-        TContext* context() {
-            return _context;
-        }
-
-        template <typename T>
-        T* context() {
-            return details::getContext<T>(_context, _internalContext);
-        }
-
-        template <typename T>
-        T* contextOrNull() {
-            return details::getContextIfTypeExists<T>(_context, _internalContext);
-        }
-
-        /*
-         * object function
-         */
         template<typename T>
-        void object(const T &obj) {
-            details::SerializeFunction<BasicSerializer, T>::invoke(*this, const_cast<T& >(obj));
+        Serializer& object(const T &obj) {
+            return serialize(*this, obj);
         }
 
-        template<typename T, typename Fnc>
-        void object(const T &obj, Fnc &&fnc) {
-            fnc(const_cast<T& >(obj));
-        }
+        //in c++17 change "class" to typename
+        template <template <typename> class Extension, typename TValue, typename Fnc>
+        Serializer& ext(const TValue& v, Fnc&& fnc ) {
+            Extension<const TValue> ext{v};
+            ext.serialize(*this, std::forward<Fnc>(fnc));
+            return *this;
+        };
 
-        /*
-         * functionality, that enables simpler serialization syntax, by including additional header
-         */
-        template<typename T, typename ... TArgs>
-        void archive(T &&head, TArgs &&... tail) {
-            //serialize object
-            details::ArchiveFunction<BasicSerializer, T>::invoke(*this, std::forward<T>(head));
-            //expand other elements
-            archive(std::forward<TArgs>(tail)...);
-        }
 
         /*
          * value overloads
          */
 
-        template<size_t VSIZE, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
-        void value(const T &v) {
-            using TValue = typename details::IntegralFromFundamental<T>::TValue;
-            _writer.template writeBytes<VSIZE>(reinterpret_cast<const TValue &>(v));
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            static_assert(std::numeric_limits<T>::is_iec559, "");
+            _writter.template writeBytes<VSIZE>(reinterpret_cast<const details::SAME_SIZE_UNSIGNED<T> &>(v));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            _writter.template writeBytes<VSIZE>(reinterpret_cast<const std::underlying_type_t<T> &>(v));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            _writter.template writeBytes<VSIZE>(v);
+            return *this;
         }
 
         /*
-         * enable bit-packing
+         * bool
          */
-        template <typename Fnc>
-        void enableBitPacking(Fnc&& fnc) {
-            procEnableBitPacking(std::forward<Fnc>(fnc), std::integral_constant<bool, TAdapterWriter::BitPackingEnabled>{});
+
+        Serializer& boolBit(bool v) {
+            _writter.writeBits(static_cast<unsigned char>(v ? 1 : 0), 1);
+            return *this;
+        }
+
+        Serializer& boolByte(bool v) {
+            _writter.template writeBytes<1>(static_cast<unsigned char>(v ? 1 : 0));
+            return *this;
         }
 
         /*
-         * extension functions
+         * range
          */
 
-        template<typename T, typename Ext, typename Fnc>
-        void ext(const T &obj, const Ext &extension, Fnc &&fnc) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
-                          "extension doesn't support overload with lambda");
-            extension.serialize(*this, _writer, obj, std::forward<Fnc>(fnc));
-        }
-
-        template<size_t VSIZE, typename T, typename Ext>
-        void ext(const T &obj, const Ext &extension) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportValueOverload,
-                          "extension doesn't support overload with `value<N>`");
-            using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
-            using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.serialize(*this, _writer, obj, [this](VType &v) { value<VSIZE>(v); });
-        }
-
-        template<typename T, typename Ext>
-        void ext(const T &obj, const Ext &extension) {
-            static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
-            static_assert(traits::ExtensionTraits<Ext,T>::SupportObjectOverload,
-                          "extension doesn't support overload with `object`");
-            using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
-            using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.serialize(*this, _writer, obj, [this](VType &v) { object(v); });
+        template<typename T>
+        Serializer& range(const T &v, const RangeSpec<T> &range) {
+            assert(details::isRangeValid(v, range));
+            _writter.template writeBits<decltype(details::getRangeValue(v, range))>(details::getRangeValue(v, range), range.bitsRequired);
+            return *this;
         }
 
         /*
-         * boolValue
+         * substitution overloads
          */
+        template<typename T, size_t N, typename Fnc>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues, Fnc &&fnc) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                fnc(*this, v);
+            return *this;
+        };
 
-        void boolValue(bool v) {
-            procBoolValue(v, std::integral_constant<bool, TAdapterWriter::BitPackingEnabled>{});
-        }
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                value<VSIZE>(v);
+            return *this;
+        };
+
+        template<typename T, size_t N>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                object(v);
+            return *this;
+        };
 
         /*
          * text overloads
          */
 
         template<size_t VSIZE, typename T>
-        void text(const T &str, size_t maxSize) {
-            static_assert(details::IsTextTraitsDefined<T>::value,
-                          "Please define TextTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use text(const T&) overload without `maxSize` for static container");
-            procText<VSIZE>(str, maxSize);
+        Serializer& text(const std::basic_string<T> &str, size_t maxSize) {
+            assert(str.size() <= maxSize);
+            auto first = std::begin(str);
+            auto last = std::end(str);
+            writeSize(std::distance(first, last));
+            procContainer<VSIZE>(first, last, std::true_type{});
+            return *this;
         }
 
-        template<size_t VSIZE, typename T>
-        void text(const T &str) {
-            static_assert(details::IsTextTraitsDefined<T>::value,
-                          "Please define TextTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use text(const T&, size_t) overload with `maxSize` for dynamic containers");
-            procText<VSIZE>(str, traits::ContainerTraits<T>::size(str));
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& text(const T (&str)[N]) {
+            auto first = std::begin(str);
+            auto last = std::next(first, std::min(std::char_traits<T>::length(str), N - 1));
+            writeSize(std::distance(first, last));
+            procContainer<VSIZE>(first, last, std::true_type{});
+            return *this;
         }
 
         /*
          * container overloads
          */
 
-        //dynamic size containers
-
         template<typename T, typename Fnc>
-        void container(const T &obj, size_t maxSize, Fnc &&fnc) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&, Fnc) overload without `maxSize` for static containers");
-            auto size = traits::ContainerTraits<T>::size(obj);
-            assert(size <= maxSize);
-            details::writeSize(_writer, size);
+        Serializer& container(const T &obj, size_t maxSize, Fnc &&fnc) {
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
             procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+            return *this;
         }
 
         template<size_t VSIZE, typename T>
-        void container(const T &obj, size_t maxSize) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&) overload without `maxSize` for static containers");
+        Serializer& container(const T &obj, size_t maxSize) {
             static_assert(VSIZE > 0, "");
-            auto size = traits::ContainerTraits<T>::size(obj);
-            assert(size <= maxSize);
-            details::writeSize(_writer, size);
-
-            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
+            //todo optimisation is possible for contigous containers, but currently there is no compile-time check for this
+            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::false_type{});
+            return *this;
         }
 
         template<typename T>
-        void container(const T &obj, size_t maxSize) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&) overload without `maxSize` for static containers");
-            auto size = traits::ContainerTraits<T>::size(obj);
-            assert(size <= maxSize);
-            details::writeSize(_writer, size);
+        Serializer& container(const T &obj, size_t maxSize) {
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
             procContainer(std::begin(obj), std::end(obj));
+            return *this;
         }
 
-        //fixed size containers
+        /*
+         * array overloads (fixed size array (std::array, and c-style array))
+         */
 
-        template<typename T, typename Fnc, typename std::enable_if<!std::is_integral<Fnc>::value>::type * = nullptr>
-        void container(const T &obj, Fnc &&fnc) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&, size_t, Fnc) overload with `maxSize` for dynamic containers");
-            procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+        //std::array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Serializer& array(const std::array<T, N> &arr, Fnc &&fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
         }
 
-        template<size_t VSIZE, typename T>
-        void container(const T &obj) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&, size_t) overload with `maxSize` for dynamic containers");
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& array(const std::array<T, N> &arr) {
             static_assert(VSIZE > 0, "");
-            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
         }
 
-        template<typename T>
-        void container(const T &obj) {
-            static_assert(details::IsContainerTraitsDefined<T>::value,
-                          "Please define ContainerTraits or include from <bitsery/traits/...>");
-            static_assert(!traits::ContainerTraits<T>::isResizable,
-                          "use container(const T&, size_t) overload with `maxSize` for dynamic containers");
-            procContainer(std::begin(obj), std::end(obj));
+        template<typename T, size_t N>
+        Serializer& array(const std::array<T, N> &arr) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
         }
 
-        void align() {
-            _writer.align();
+        //c-style array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Serializer& array(const T (&arr)[N], Fnc &&fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& array(const T (&arr)[N]) {
+            static_assert(VSIZE > 0, "");
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Serializer& array(const T (&arr)[N]) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+
+        Serializer& align() {
+            _writter.align();
+            return *this;
         }
 
         //overloads for functions with explicit type size
+        template<typename T> Serializer& value1(T &&v) { return value<1>(std::forward<T>(v)); }
+        template<typename T> Serializer& value2(T &&v) { return value<2>(std::forward<T>(v)); }
+        template<typename T> Serializer& value4(T &&v) { return value<4>(std::forward<T>(v)); }
+        template<typename T> Serializer& value8(T &&v) { return value<8>(std::forward<T>(v)); }
 
-        template<typename T>
-        void value1b(T &&v) { value<1>(std::forward<T>(v)); }
+        template<typename T, size_t N> Serializer& substitution1
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<1>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution2
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<2>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution4
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<4>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution8
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<8>(v, expectedValues); };
 
-        template<typename T>
-        void value2b(T &&v) { value<2>(std::forward<T>(v)); }
+        template<typename T> Serializer& text1(const std::basic_string<T> &str, size_t maxSize) {
+            return text<1>(str, maxSize); }
+        template<typename T> Serializer& text2(const std::basic_string<T> &str, size_t maxSize) {
+            return text<2>(str, maxSize); }
+        template<typename T> Serializer& text4(const std::basic_string<T> &str, size_t maxSize) {
+            return text<4>(str, maxSize); }
 
-        template<typename T>
-        void value4b(T &&v) { value<4>(std::forward<T>(v)); }
+        template<typename T, size_t N> Serializer& text1(const T (&str)[N]) { return text<1>(str); }
+        template<typename T, size_t N> Serializer& text2(const T (&str)[N]) { return text<2>(str); }
+        template<typename T, size_t N> Serializer& text4(const T (&str)[N]) { return text<4>(str); }
 
-        template<typename T>
-        void value8b(T &&v) { value<8>(std::forward<T>(v)); }
+        template<typename T> Serializer& container1(T &&obj, size_t maxSize) {
+            return container<1>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container2(T &&obj, size_t maxSize) {
+            return container<2>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container4(T &&obj, size_t maxSize) {
+            return container<4>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container8(T &&obj, size_t maxSize) {
+            return container<8>(std::forward<T>(obj), maxSize); }
 
-        template<typename T, typename Ext>
-        void ext1b(const T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); }
+        template<typename T, size_t N> Serializer& array1(const std::array<T, N> &arr) { return array<1>(arr); }
+        template<typename T, size_t N> Serializer& array2(const std::array<T, N> &arr) { return array<2>(arr); }
+        template<typename T, size_t N> Serializer& array4(const std::array<T, N> &arr) { return array<4>(arr); }
+        template<typename T, size_t N> Serializer& array8(const std::array<T, N> &arr) { return array<8>(arr); }
 
-        template<typename T, typename Ext>
-        void ext2b(const T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T, typename Ext>
-        void ext4b(const T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T, typename Ext>
-        void ext8b(const T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); }
-
-        template<typename T>
-        void text1b(const T &str, size_t maxSize) { text<1>(str, maxSize); }
-
-        template<typename T>
-        void text2b(const T &str, size_t maxSize) { text<2>(str, maxSize); }
-
-        template<typename T>
-        void text4b(const T &str, size_t maxSize) { text<4>(str, maxSize); }
-
-        template<typename T>
-        void text1b(const T &str) { text<1>(str); }
-
-        template<typename T>
-        void text2b(const T &str) { text<2>(str); }
-
-        template<typename T>
-        void text4b(const T &str) { text<4>(str); }
-
-        template<typename T>
-        void container1b(T &&obj, size_t maxSize) { container<1>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container2b(T &&obj, size_t maxSize) { container<2>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container4b(T &&obj, size_t maxSize) { container<4>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container8b(T &&obj, size_t maxSize) { container<8>(std::forward<T>(obj), maxSize); }
-
-        template<typename T>
-        void container1b(T &&obj) { container<1>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container2b(T &&obj) { container<2>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container4b(T &&obj) { container<4>(std::forward<T>(obj)); }
-
-        template<typename T>
-        void container8b(T &&obj) { container<8>(std::forward<T>(obj)); }
+        template<typename T, size_t N> Serializer& array1(const T (&arr)[N]) { return array<1>(arr); }
+        template<typename T, size_t N> Serializer& array2(const T (&arr)[N]) { return array<2>(arr); }
+        template<typename T, size_t N> Serializer& array4(const T (&arr)[N]) { return array<4>(arr); }
+        template<typename T, size_t N> Serializer& array8(const T (&arr)[N]) { return array<8>(arr); }
 
     private:
-        friend AdapterAccess;
+        Writter &_writter;
 
-        TAdapterWriter _writer;
-        TContext* _context;
-        typename TWriter::TConfig::InternalContext _internalContext;
+        void writeSize(const size_t size) {
+            if (size < 0x80u) {
+                _writter.writeBits(1u, 1);
+                _writter.writeBits(size, 7);
+            } else if (size < 0x4000u) {
+                _writter.writeBits(2u,2);
+                _writter.writeBits(size, 14);
+            } else {
+                assert(size < 0x40000000u);
+                _writter.writeBits(0u,2);
+                _writter.writeBits(size, 30);
+            }
+        }
 
         //process value types
         //false_type means that we must process all elements individually
         template<size_t VSIZE, typename It>
         void procContainer(It first, It last, std::false_type) {
-            for (; first != last; ++first)
+            for (;first != last; ++first)
                 value<VSIZE>(*first);
-        }
+        };
 
         //process value types
         //true_type means, that we can copy whole buffer
         template<size_t VSIZE, typename It>
         void procContainer(It first, It last, std::true_type) {
-            using TValue = typename std::decay<decltype(*first)>::type;
-            using TIntegral = typename details::IntegralFromFundamental<TValue>::TValue;
-			if (first != last)
-				_writer.template writeBuffer<VSIZE>(reinterpret_cast<const TIntegral*>(&(*first)),
-                                                    static_cast<size_t>(std::distance(first, last)));
-        }
+            if (first != last)
+                _writter.template writeBuffer<VSIZE>(&(*first), std::distance(first, last));
+        };
 
         //process by calling functions
         template<typename It, typename Fnc>
         void procContainer(It first, It last, Fnc fnc) {
-            using TValue = typename std::decay<decltype(*first)>::type;
-            for (; first != last; ++first) {
-                fnc(const_cast<TValue&>(*first));
-            }
-        }
-
-        //process text,
-        template<size_t VSIZE, typename T>
-        void procText(const T& str, size_t maxSize) {
-            auto length = traits::TextTraits<T>::length(str);
-            assert((length + (traits::TextTraits<T>::addNUL ? 1u : 0u)) <= maxSize);
-            details::writeSize(_writer, length);
-            auto begin = std::begin(str);
-            procContainer<VSIZE>(begin, std::next(begin, length), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
-        }
+            for (;first != last; ++first)
+                fnc(*this, *first);
+        };
 
         //process object types
         template<typename It>
         void procContainer(It first, It last) {
-            for (; first != last; ++first)
+            for (;first != last; ++first)
                 object(*first);
-        }
-
-        //proc bool writing bit or byte, depending on if BitPackingEnabled or not
-        void procBoolValue(bool v, std::true_type) {
-            _writer.writeBits(static_cast<unsigned char>(v ? 1 : 0), 1);
-        }
-
-        void procBoolValue(bool v, std::false_type) {
-            _writer.template writeBytes<1>(static_cast<unsigned char>(v ? 1 : 0));
-        }
-
-        //enable bit-packing or do nothing if it is already enabled
-        template <typename Fnc>
-        void procEnableBitPacking(const Fnc& fnc, std::true_type) {
-            fnc(*this);
-        }
-
-        template <typename Fnc>
-        void procEnableBitPacking(const Fnc& fnc, std::false_type) {
-            //create serializer using bitpacking wrapper
-            BPEnabledType tmp(_writer, _context);
-            fnc(tmp);
-        }
-
-        //these are dummy functions for extensions that have TValue = void
-        void object(const details::DummyType&) {
-
-        }
-
-        template <size_t VSIZE>
-        void value(const details::DummyType&) {
-
-        }
-
-        //dummy function, that stops archive variadic arguments expansion
-        void archive() {
-        }
+        };
 
     };
 
-    //helper type
-    template <typename Adapter>
-    using Serializer = BasicSerializer<AdapterWriter<Adapter, DefaultConfig>>;
-
-    //helper function that set ups all the basic steps and after serialziation returns serialized bytes count
-    template <typename Adapter, typename T>
-    size_t quickSerialization(Adapter adapter, const T& value) {
-        Serializer<Adapter> ser{std::move(adapter)};
-        ser.object(value);
-        auto& w = AdapterAccess::getWriter(ser);
-        w.flush();
-        return w.writtenBytesCount();
-    }
-
-    template <typename T>
-    size_t quickMeasureSize(const T& value) {
-        BasicSerializer<MeasureSize> ser {nullptr};
-        ser.object(value);
-        auto& w = AdapterAccess::getWriter(ser);
-        w.flush();
-        return w.writtenBytesCount();
-    }
-
 }
 #endif //BITSERY_SERIALIZER_H

include/bitsery/traits/array.h

@@ -1,44 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_ARRAY_H
-#define BITSERY_TRAITS_STD_ARRAY_H
-
-#include "core/std_defaults.h"
-#include <array>
-
-namespace bitsery {
-
-    namespace traits {
-        template<typename T, size_t N>
-        struct ContainerTraits<std::array<T, N>>
-                :public StdContainer<std::array<T, N>, false, true> {};
-
-        template<typename T, size_t N>
-        struct BufferAdapterTraits<std::array<T, N>>
-                :public StdContainerForBufferAdapter<std::array<T, N>> {};
-    }
-
-}
-
-#endif //BITSERY_TYPE_TRAITS_STD_ARRAY_H

include/bitsery/traits/core/std_defaults.h

@@ -1,85 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_TRAITS_CORE_STD_DEFAULTS_H
-#define BITSERY_TRAITS_CORE_STD_DEFAULTS_H
-
-#include "traits.h"
-#include <iostream>
-
-namespace bitsery {
-    namespace traits {
-
-        /*
-         * these are helper types, to easier write specializations for std types
-         */
-
-        template<typename T, bool Resizable, bool Contiguous>
-        struct StdContainer {
-            using TValue = typename T::value_type;
-            static constexpr bool isResizable = Resizable;
-            static constexpr bool isContiguous = Contiguous;
-            static size_t size(const T& container) {
-                return container.size();
-            }
-        };
-
-        //specialization for resizable
-        template<typename T, bool Contiguous>
-        struct StdContainer<T, true, Contiguous> {
-            using TValue = typename T::value_type;
-            static constexpr bool isResizable = true;
-            static constexpr bool isContiguous = Contiguous;
-            static size_t size(const T& container) {
-                return container.size();
-            }
-            static void resize(T& container, size_t size) {
-                container.resize(size);
-            }
-        };
-
-        template <typename T, bool Resizable = ContainerTraits<T>::isResizable>
-        struct StdContainerForBufferAdapter {
-            using TIterator = typename T::iterator;
-            using TValue = typename ContainerTraits<T>::TValue;
-        };
-
-        //specialization for resizable buffers
-        template <typename T>
-        struct StdContainerForBufferAdapter<T, true> {
-
-            static void increaseBufferSize(T& container) {
-                //since we're writing to buffer use different resize strategy than default implementation
-                //when small size grow faster, to avoid thouse 2/4/8/16... byte allocations
-                auto newSize = static_cast<size_t>(container.size() * 1.5 + 128);
-                //make data cache friendly
-                newSize -= newSize % 64;//64 is cache line size
-                container.resize(std::max(newSize, container.capacity()));
-            }
-            using TIterator = typename T::iterator;
-            using TValue = typename ContainerTraits<T>::TValue;
-        };
-
-    }
-}
-
-#endif //BITSERY_TRAITS_CORE_STD_DEFAULTS_H

include/bitsery/traits/core/traits.h

@@ -1,184 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#ifndef BITSERY_TRAITS_CORE_TRAITS_H
-#define BITSERY_TRAITS_CORE_TRAITS_H
-
-#include <type_traits>
-#include "../../details/not_defined_type.h"
-
-namespace bitsery {
-    namespace traits {
-
-        /*
-         * core library traits, used to extend library for custom types
-         */
-
-        //traits for extension
-        template<typename Extension, typename T>
-        struct ExtensionTraits {
-            //this type is used, when using extesion without custom lambda
-            // eg.: extension4b>(obj, myextension{}) will call s.value4b(obj) for TValue
-            // or extesion(obj, myextension{})  will call s.object(obj) for TValue
-            //when this is void, it will compile, but value and object overloads will do nothing.
-            using TValue = details::NotDefinedType;
-
-            //does extension support ext<N>(...) syntax, by calling value<N> with TValue
-            static constexpr bool SupportValueOverload = false;
-            //does extension support ext(...) syntax, by calling object with TValue
-            static constexpr bool SupportObjectOverload = false;
-            //does extension support ext(..., lambda)
-            static constexpr bool SupportLambdaOverload = false;
-        };
-
-        //primary traits for containers
-        template<typename T>
-        struct ContainerTraits {
-
-            using TValue = details::NotDefinedType;
-
-            static constexpr bool isResizable = false;
-            //contiguous arrays has oppurtunity to memcpy whole buffer directly when using funtamental types
-            //contiguous doesn't nesessary equal to random access iterator.
-            //contiguous hopefully will be available in c++20
-            static constexpr bool isContiguous = false;
-            //resize function, called only if container is resizable
-            static void resize(T& , size_t ) {
-                static_assert(std::is_void<T>::value,
-                              "Define ContainerTraits or include from <bitsery/traits/...> to use as container");
-            }
-            //get container size
-            static size_t size(const T& ) {
-                static_assert(std::is_void<T>::value,
-                              "Define ContainerTraits or include from <bitsery/traits/...> to use as container");
-                return 0u;
-            }
-        };
-
-        //specialization for C style array
-        template<typename T, size_t N>
-        struct ContainerTraits<T[N]> {
-            using TValue = T;
-            static constexpr bool isResizable = false;
-            static constexpr bool isContiguous = true;
-            static size_t size(const T (&)[N]) {
-                return N;
-            }
-        };
-
-        //specialization for initializer list.
-        //only serializer can use it
-        template<typename T>
-        struct ContainerTraits<std::initializer_list<T>> {
-            using TValue = T;
-            static constexpr bool isResizable = false;
-            static constexpr bool isContiguous = true;
-            static size_t size(const std::initializer_list<T>& container) {
-                return container.size();
-            }
-        };
-
-        //specialization for pointer type buffer
-        //only deserializer can use it
-        template <typename T>
-        struct ContainerTraits<const T*> {
-            using TValue = T;
-            static constexpr bool isResizable = false;
-            static constexpr bool isContiguous = true;
-            static size_t size(const T* ) {
-                static_assert(std::is_void<T>::value, "cannot get size for container of type T*");
-                return 0u;
-            }
-        };
-
-        template <typename T>
-        struct ContainerTraits<T*> {
-            using TValue = T;
-            static constexpr bool isResizable = false;
-            static constexpr bool isContiguous = true;
-            static size_t size(const T* ) {
-                static_assert(std::is_void<T>::value, "cannot get size for container of type T*");
-                return 0u;
-            }
-        };
-
-
-
-        //traits for text, default adds null-terminated character at the end
-        template<typename T>
-        struct TextTraits {
-            using TValue = details::NotDefinedType;
-            //if container is not null-terminated by default, add NUL at the end
-            static constexpr bool addNUL = true;
-
-            //get length of null terminated container
-            static size_t length(const T& ) {
-                static_assert(std::is_void<T>::value,
-                              "Define TextTraits or include from <bitsery/traits/...> to use as text");
-                return 0u;
-            }
-        };
-
-        //traits only for buffer adapters
-        template <typename T>
-        struct BufferAdapterTraits {
-            //this function is only applies to resizable containers
-
-            //this function is only used by Writer, when writing data to buffer,
-            //it is called only current buffer size is not enough to write.
-            //it is used to dramaticaly improve performance by updating buffer directly
-            //instead of using back_insert_iterator to append each byte to buffer.
-            //thats why Writer return range iterators
-
-            static void increaseBufferSize(T& ) {
-                static_assert(std::is_void<T>::value,
-                              "Define BufferAdapterTraits or include from <bitsery/traits/...> to use as buffer adapter container");
-            }
-
-            using TIterator = details::NotDefinedType;
-            using TValue = typename ContainerTraits<T>::TValue;
-        };
-
-        //specialization for c-style buffer
-        template <typename T, size_t N>
-        struct BufferAdapterTraits<T[N]> {
-            using TIterator = T*;
-            using TValue = T;
-        };
-
-        //specialization for pointer type buffer
-        template <typename T>
-        struct BufferAdapterTraits<const T*> {
-            using TIterator = const T*;
-            using TValue = T;
-        };
-
-        template <typename T>
-        struct BufferAdapterTraits<T*> {
-            using TIterator = T*;
-            using TValue = T;
-        };
-
-    }
-}
-
-#endif //BITSERY_TRAITS_CORE_TRAITS_H

include/bitsery/traits/deque.h

@@ -1,42 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_DEQUE_H
-#define BITSERY_TRAITS_STD_DEQUE_H
-
-#include "core/std_defaults.h"
-#include <deque>
-
-namespace bitsery {
-
-    namespace traits {
-
-        template<typename ... TArgs>
-        struct ContainerTraits<std::deque<TArgs...>>
-                : public StdContainer<std::deque<TArgs...>, true, false> {};
-
-    }
-
-}
-
-#endif //BITSERY_TRAITS_STD_DEQUE_H

include/bitsery/traits/forward_list.h

@@ -1,49 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_FORWARD_LIST_H
-#define BITSERY_TRAITS_STD_FORWARD_LIST_H
-
-#include <forward_list>
-
-namespace bitsery {
-
-    namespace traits {
-
-        template<typename ... TArgs>
-        struct ContainerTraits<std::forward_list<TArgs...>> {
-            using TValue = typename std::forward_list<TArgs...>::value_type;
-            static constexpr bool isResizable = true;
-            static constexpr bool isContiguous = false;
-            static size_t size(const std::forward_list<TArgs...>& container) {
-                return static_cast<size_t>(std::distance(container.begin(), container.end()));
-            }
-            static void resize(std::forward_list<TArgs...>& container, size_t size) {
-                container.resize(size);
-            }
-        };
-    }
-}
-
-
-#endif //BITSERY_TRAITS_STD_FORWARD_LIST_H

include/bitsery/traits/list.h

@@ -1,42 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_LIST_H
-#define BITSERY_TRAITS_STD_LIST_H
-
-#include "core/std_defaults.h"
-#include <list>
-
-namespace bitsery {
-
-    namespace traits {
-
-        template<typename ... TArgs>
-        struct ContainerTraits<std::list<TArgs...>>
-                : public StdContainer<std::list<TArgs...>, true, false> {};
-
-    }
-
-}
-
-#endif //BITSERY_TRAITS_STD_LIST_H

include/bitsery/traits/string.h

@@ -1,71 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_STRING_H
-#define BITSERY_TRAITS_STD_STRING_H
-
-#include "core/std_defaults.h"
-#include <string>
-
-namespace bitsery {
-
-    namespace traits {
-
-        // specialization for string, because string is already included for std::char_traits
-
-        template<typename ... TArgs>
-        struct ContainerTraits<std::basic_string<TArgs...>>
-            :public StdContainer<std::basic_string<TArgs...>, true, true> {};
-
-        template <typename ... TArgs>
-        struct TextTraits<std::basic_string<TArgs...>> {
-            using TValue = typename ContainerTraits<std::basic_string<TArgs...>>::TValue;
-            //string is automatically null-terminated
-            static constexpr bool addNUL = false;
-
-            //is is not 100% accurate, but for performance reasons assume that string stores text, not binary data
-            static size_t length(const std::basic_string<TArgs...>& str) {
-                return str.size();
-            }
-        };
-
-        //specialization for c-array
-        template <typename T, size_t N>
-        struct TextTraits<T[N]> {
-            using TValue = T;
-            static constexpr bool addNUL = true;
-
-            static size_t length(const T (&container)[N]) {
-                return std::char_traits<T>::length(container);
-            }
-        };
-
-        template<typename ... TArgs>
-        struct BufferAdapterTraits<std::basic_string<TArgs...>>
-                :public StdContainerForBufferAdapter<std::basic_string<TArgs...>> {};
-
-    }
-
-}
-
-#endif //BITSERY_TRAITS_VECTOR_H

include/bitsery/traits/vector.h

@@ -1,50 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#ifndef BITSERY_TRAITS_STD_VECTOR_H
-#define BITSERY_TRAITS_STD_VECTOR_H
-
-#include "core/std_defaults.h"
-#include <vector>
-
-namespace bitsery {
-
-    namespace traits {
-        template<typename ... TArgs>
-        struct ContainerTraits<std::vector<TArgs...>>
-                :public StdContainer<std::vector<TArgs...>, true, true> {};
-
-        //bool vector is not contiguous, do not copy it directly to buffer
-        template<typename Allocator>
-        struct ContainerTraits<std::vector<bool, Allocator>>
-                :public StdContainer<std::vector<bool, Allocator>, true, false> {};
-
-        template<typename ... TArgs>
-        struct BufferAdapterTraits<std::vector<TArgs...>>
-                :public StdContainerForBufferAdapter<std::vector<TArgs...>> {};
-
-    }
-
-}
-
-#endif //BITSERY_TRAITS_STD_VECTOR_H

scripts/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set(CTEST_PROJECT_NAME "bitsery")
-
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "my.cdash.org")
-set(CTEST_DROP_LOCATION "/submit.php?project=bitsery")
-set(CTEST_DROP_SITE_CDASH TRUE)
-

scripts/build.bitsery.cmake

@@ -1,20 +0,0 @@
-# run from linux shell:
-#$ ctest -S build.bitsery.cmake
-set(CTEST_SOURCE_DIRECTORY "..") #path to bitsery root (top-level) directory
-set(CTEST_BINARY_DIRECTORY "build")
-
-set(ENV{CXXFLAGS} "--coverage")
-#when using Ninja generator, ctest_coverage cannot find files...
-set(CTEST_CMAKE_GENERATOR "CodeBlocks - Unix Makefiles")
-set(CTEST_USE_LAUNCHERS 1)
-
-set(CTEST_COVERAGE_COMMAND "gcov")
-
-configure_file(CTestConfig.cmake ${CTEST_SOURCE_DIRECTORY}/CTestConfig.cmake)
-
-ctest_start("Continuous")
-ctest_configure(OPTIONS "-DBITSERY_BUILD_EXAMPLES=OFF;-DBITSERY_BUILD_TESTS=ON")
-ctest_build()
-ctest_test(BUILD ${CTEST_BINARY_DIRECTORY}/tests)
-ctest_coverage()
-#ctest_submit()

scripts/show_coverage.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-BUILD_DIR=$1
-TESTS_BUILD_DIR=$BUILD_DIR/tests/CMakeFiles/
-COV_INFO=$TESTS_BUILD_DIR/bitsery_coverage.info
-lcov --directory $TESTS_BUILD_DIR --capture --output-file $COV_INFO
-lcov --extract $COV_INFO '*include/bitsery*' --output-file $COV_INFO.clean
-genhtml --output-directory $TESTS_BUILD_DIR/coverage_web $COV_INFO.clean
-xdg-open $TESTS_BUILD_DIR/coverage_web/index.html

tests/CMakeLists.txt

@@ -20,43 +20,55 @@
 #OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #SOFTWARE.
 
-cmake_minimum_required(VERSION 3.5)
-project(bitsery_tests CXX)
+cmake_minimum_required(VERSION 3.2)
+set(TestProjectName bitsery_tests)
+project(${TestProjectName} C CXX)
 
-find_package(GTest 1.8 REQUIRED)
 
-if (NOT TARGET Bitsery::bitsery)
-    message(FATAL_ERROR "Bitsery::bitsery alias not set. Please generate CMake from bitsery root directory.")
-endif()
+find_package(Threads REQUIRED)
+
+#add googletest external project
+#USE_GMOCK enable gmock
+#exports variables GTEST_INCLUDE_DIRS, GTEST_LIBS_DIR, GTEST_LIBNAME, GTEST_MAIN_LIBNAME
+set(ExtCMakeFilesDir ${CMAKE_SOURCE_DIR}/ext)
+set(UseGMock ON)
+add_subdirectory(${ExtCMakeFilesDir}/gtest ${CMAKE_BINARY_DIR}/gtest)
+
+#this helps idea to know which files are actually used
+file(GLOB_RECURSE IncludeHeaders ${CMAKE_SOURCE_DIR}/include/bitsery/*.h)
+# set common include folder for module
+include_directories(SYSTEM ${GTestIncludeDirs})
+include_directories(${CMAKE_SOURCE_DIR}/include)
 
 file(GLOB TestSourceFiles ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
     message(WARNING "extension tests for optional is disable for VS, because VS currenty doesn't have <optional>")
-    list(REMOVE_ITEM TestSourceFiles ${CMAKE_CURRENT_SOURCE_DIR}/serialization_ext_std_optional.cpp)
+    list(REMOVE_ITEM TestSourceFiles ${CMAKE_CURRENT_SOURCE_DIR}/serialization_ext_optional.cpp)
 endif()
 
-enable_testing()
+include(${ExtCMakeFilesDir}/LinkTestLib.cmake)
 
-foreach(TestFile ${TestSourceFiles})
+FOREACH(TestFile ${TestSourceFiles})
     get_filename_component(TestName ${TestFile} NAME_WE)
-    set(TestName bitsery.test.${TestName})
-    add_executable(${TestName} ${TestFile})
-    target_link_libraries(${TestName} PRIVATE GTest::Main Bitsery::bitsery)
+    set(TestName TEST_${TestName})
+    add_executable(${TestName} ${TestFile} ${IncludeHeaders})
+    LinkTestLib(${TestName})
+
     add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)
-endforeach()
 
-#======================= setup development environment ====================
+ENDFOREACH()
 
-# get all header files for IDE  (in my case Clion) and create dummy project that consumes theses files
-get_directory_property(ParentDir PARENT_DIRECTORY)
-if (ParentDir)
-    # only include when working from root project (Bitsery)
-    file(GLOB_RECURSE HeadersForIDE ${ParentDir}/include/bitsery/*.h)
-    # create dummy target IDE
-    file(WRITE ${CMAKE_BINARY_DIR}/dummy_for_ide.cpp "//generated by CMake to create dummy target with all includes for IDE.")
-    add_library(bitsery.dummy_for_ide ${CMAKE_BINARY_DIR}/dummy_for_ide.cpp )
-    # add headers so IDE correctly show them
-    target_sources(bitsery.dummy_for_ide PRIVATE ${HeadersForIDE} serialization_test_utils.h)
-    target_link_libraries(bitsery.dummy_for_ide PRIVATE GTest::Main Bitsery::bitsery)
+#all in one tests for code coverage
+add_executable(${TestProjectName} ${TestSourceFiles})
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    include(${ExtCMakeFilesDir}/CodeCoverage.cmake)
+    target_compile_options(${TestProjectName} PUBLIC -O0 -fprofile-arcs -ftest-coverage)
+    target_link_libraries(${TestProjectName} -O0 -fprofile-arcs -ftest-coverage)
+    setup_target_for_coverage(tests_coverage ${TestProjectName} coverage)
 endif()
+
+LinkTestLib(${TestProjectName})
+
+

tests/adapter_stream.cpp

@@ -1,161 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#include <gmock/gmock.h>
-#include <bitsery/adapter/stream.h>
-#include <bitsery/adapter_writer.h>
-#include <bitsery/adapter_reader.h>
-#include <bitsery/traits/vector.h>
-#include <bitsery/traits/array.h>
-#include <bitsery/traits/string.h>
-#include <sstream>
-
-//some helper types
-using Stream = std::stringstream;
-using OutputAdapter = bitsery::OutputStreamAdapter;
-using InputAdapter = bitsery::InputStreamAdapter ;
-using Writer = bitsery::AdapterWriter<bitsery::OutputStreamAdapter, bitsery::DefaultConfig>;
-using Reader = bitsery::AdapterReader<bitsery::InputStreamAdapter, bitsery::DefaultConfig>;
-
-static constexpr size_t InternalBufferSize = 128;
-using BufferedAdapterInternalBuffer = std::array<char, InternalBufferSize>;
-using OutputBufferedAdapter = bitsery::BasicBufferedOutputStreamAdapter<char, std::char_traits<char>, BufferedAdapterInternalBuffer>;
-using BufferedWriter = bitsery::AdapterWriter<OutputBufferedAdapter, bitsery::DefaultConfig>;
-
-using testing::Eq;
-
-TEST(AdapterIOStream, CorrectlyReturnsIsCompletedSuccessfully) {
-    //setup data
-    uint8_t t1 = 111;
-
-    Stream buf{};
-    Writer w{{buf}};
-    w.writeBytes<1>(t1);
-    w.flush();
-
-    Reader r{{buf}};
-
-    uint8_t r1{};
-    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(false));
-    r.readBytes<1>(r1);
-    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(true));
-    EXPECT_THAT(r1, Eq(t1));
-}
-
-TEST(AdapterIOStream, ReadingMoreThanAvailableReturnsZero) {
-    //setup data
-    uint8_t t1 = 111;
-
-    Stream buf{};
-    Writer w{{buf}};
-    w.writeBytes<1>(t1);
-    w.flush();
-
-    Reader r{{buf}};
-
-    uint8_t r1{};
-    r.readBytes<1>(r1);
-    r.readBytes<1>(r1);
-    EXPECT_THAT(r1, Eq(0));
-}
-
-//this is strange, but probably stringstream doesnt use any of the base methods that sets io_base::iostate flags
-TEST(AdapterIOStream, WhenReadingMoreThanAvailableThenDataOverflow) {
-    //setup data
-    uint8_t t1 = 111;
-
-    Stream buf{};
-    Writer w{{buf}};
-    w.writeBytes<1>(t1);
-    w.flush();
-
-    Reader r{{buf}};
-
-    uint8_t r1{};
-    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(false));
-    EXPECT_THAT(r.error(), Eq(bitsery::ReaderError::NoError));
-    r.readBytes<1>(r1);
-    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(true));
-    EXPECT_THAT(r.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(r1, Eq(t1));
-    r.readBytes<1>(r1);
-    r.readBytes<1>(r1);
-    EXPECT_THAT(r1, Eq(0));
-    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(false));
-    EXPECT_THAT(r.error(), Eq(bitsery::ReaderError::DataOverflow));
-
-}
-
-
-template<typename T>
-class AdapterBufferedOutputStream : public testing::Test {
-public:
-    using Buffer = T;
-    using Adapter = bitsery::BasicBufferedOutputStreamAdapter<char, std::char_traits<char>, Buffer>;
-    using Writer = bitsery::AdapterWriter<Adapter, bitsery::DefaultConfig>;
-
-    static constexpr size_t InternalBufferSize = 128;
-
-    Stream stream{};
-
-    Writer writer{{stream, 128}};
-};
-
-using BufferedAdapterInternalBufferTypes = ::testing::Types<
-        std::vector<char>,
-        std::array<char, 128>,
-        std::string
->;
-
-TYPED_TEST_CASE(AdapterBufferedOutputStream, BufferedAdapterInternalBufferTypes);
-
-TYPED_TEST(AdapterBufferedOutputStream, WhenBufferOverflowThenWriteBufferAndRemainingDataToStream) {
-    uint8_t x{};
-    for (auto i = 0u; i < TestFixture::InternalBufferSize; ++i)
-        this->writer.template writeBytes<1>(x);
-    EXPECT_TRUE(this->stream.str().empty());
-    this->writer.template writeBytes<1>(x);
-    EXPECT_THAT(this->stream.str().size(), Eq(TestFixture::InternalBufferSize + 1));
-}
-
-TYPED_TEST(AdapterBufferedOutputStream, WhenFlushThenWriteImmediately) {
-    uint8_t x{};
-    this->writer.template writeBytes<1>(x);
-    EXPECT_THAT(this->stream.str().size(), Eq(0));
-    this->writer.flush();
-    EXPECT_THAT(this->stream.str().size(), Eq(1));
-    this->writer.flush();
-    EXPECT_THAT(this->stream.str().size(), Eq(1));
-}
-
-TYPED_TEST(AdapterBufferedOutputStream, WhenBufferIsStackAllocatedThenBufferSizeViaCtorHasNoEffect) {
-
-    //create writer with half the internal buffer size
-    //for std::vector it should overflow, and for std::array it should have no effect
-    typename TestFixture::Writer w{{this->stream, TestFixture::InternalBufferSize / 2}};
-
-    uint8_t x{};
-    for (auto i = 0u; i < TestFixture::InternalBufferSize; ++i)
-        w.template writeBytes<1>(x);
-    static constexpr bool ShouldWriteToStream = bitsery::traits::ContainerTraits<typename TestFixture::Buffer>::isResizable;
-    EXPECT_THAT(this->stream.str().empty(), ::testing::Ne(ShouldWriteToStream));
-}

tests/buffer_bits_op.cpp

@@ -0,0 +1,205 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+#include <gmock/gmock.h>
+#include <bitsery/buffer_writer.h>
+#include <bitsery/buffer_reader.h>
+#include <bitsery/details/serialization_common.h>
+
+using testing::Eq;
+using testing::ContainerEq;
+using bitsery::BufferWriter;
+using bitsery::BufferReader;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
+
+struct IntegralUnsignedTypes {
+    uint32_t a;
+    uint16_t b;
+    uint8_t c;
+    uint8_t d;
+    uint64_t e;
+};
+
+template <typename T>
+constexpr size_t getBits(T v) {
+    return bitsery::details::calcRequiredBits<T>({}, v);
+};
+
+TEST(BufferBitsOperations, WriteAndReadBits) {
+    //setup data
+    constexpr IntegralUnsignedTypes data{
+        485454,//bits 19
+        45978,//bits 16
+        0,//bits 1
+        36,//bits 6
+        479845648946//bits 39
+    };
+
+    constexpr size_t aBITS = getBits(data.a) + 2;
+    constexpr size_t bBITS = getBits(data.b) + 0;
+    constexpr size_t cBITS = getBits(data.c) + 2;
+    constexpr size_t dBITS = getBits(data.d) + 1;
+    constexpr size_t eBITS = getBits(data.e) + 8;
+
+    //create and write to buffer
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(data.a, aBITS);
+    bw.writeBits(data.b, bBITS);
+    bw.writeBits(data.c, cBITS);
+    bw.writeBits(data.d, dBITS);
+    bw.writeBits(data.e, eBITS);
+    bw.flush();
+    auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(bytesCount));
+    //read from buffer
+    BufferReader br{buf};
+    IntegralUnsignedTypes res;
+
+    br.readBits(res.a, aBITS);
+    br.readBits(res.b, bBITS);
+    br.readBits(res.c, cBITS);
+    br.readBits(res.d, dBITS);
+    br.readBits(res.e, eBITS);
+
+    EXPECT_THAT(res.a, Eq(data.a));
+    EXPECT_THAT(res.b, Eq(data.b));
+    EXPECT_THAT(res.c, Eq(data.c));
+    EXPECT_THAT(res.d, Eq(data.d));
+    EXPECT_THAT(res.e, Eq(data.e));
+
+}
+
+TEST(BufferBitsOperations, WhenFinishedFlushWriter) {
+
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(3u, 2);
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(0));
+    bw.flush();
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
+
+}
+
+TEST(BufferBitsOperations, BufferSizeIsCountedPerByteNotPerBit) {
+    //setup data
+
+    //create and write to buffer
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(7u,3);
+    bw.flush();
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
+
+    //read from buffer
+    BufferReader br{buf};
+    uint16_t tmp;
+    EXPECT_THAT(br.readBits(tmp,4), Eq(true));
+    EXPECT_THAT(br.readBits(tmp,2), Eq(true));
+    EXPECT_THAT(br.readBits(tmp,2), Eq(true));
+    EXPECT_THAT(br.readBits(tmp,2), Eq(false));
+
+    //part of next byte
+    BufferReader br1{buf};
+    EXPECT_THAT(br1.readBits(tmp,2), Eq(true));
+    EXPECT_THAT(br1.readBits(tmp,7), Eq(false));
+
+    //bigger than byte
+    BufferReader br2{buf};
+    EXPECT_THAT(br2.readBits(tmp,9), Eq(false));
+}
+
+TEST(BufferBitsOperations, ConsecutiveCallsToAlignHasNoEffect) {
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(3u, 2);
+    //3 calls to align after 1st data
+    bw.align();
+    bw.align();
+    bw.align();
+    bw.writeBits(7u, 3);
+    //1 call to align after 2nd data
+    bw.align();
+    bw.writeBits(15u, 4);
+    bw.flush();
+
+    unsigned char tmp;
+    BufferReader br{buf};
+    EXPECT_THAT(br.readBits(tmp,2), Eq(true));
+    EXPECT_THAT(tmp, Eq(3u));
+    EXPECT_THAT(br.align(), Eq(true));
+
+    EXPECT_THAT(br.readBits(tmp,3), Eq(true));
+    EXPECT_THAT(tmp, Eq(7u));
+    EXPECT_THAT(br.align(), Eq(true));
+    EXPECT_THAT(br.align(), Eq(true));
+    EXPECT_THAT(br.align(), Eq(true));
+
+    EXPECT_THAT(br.readBits(tmp,4), Eq(true));
+    EXPECT_THAT(tmp, Eq(15u));
+}
+
+
+
+TEST(BufferBitsOperations, WhenAlignedFlushHasNoEffect) {
+    //setup data
+
+    //create and write to buffer
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(3u, 2);
+    bw.align();
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
+    bw.flush();
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
+}
+
+
+TEST(BufferBitsOperations, AlignMustWriteZerosBits) {
+    //setup data
+
+    //create and write to buffer
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    //write 2 bits and align
+    bw.writeBits(3u, 2);
+    bw.align();
+
+    unsigned char tmp;
+    BufferReader br1{buf};
+    br1.readBits(tmp,2);
+    //read aligned bits
+    EXPECT_THAT(br1.readBits(tmp,6), Eq(true));
+    EXPECT_THAT(tmp, Eq(0));
+
+    BufferReader br2{buf};
+    //read 2 bits
+    br2.readBits(tmp,2);
+    EXPECT_THAT(br2.align(), Eq(true));
+}

tests/buffer_bytes_op.cpp

@@ -0,0 +1,274 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//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:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//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.
+
+
+#include <gmock/gmock.h>
+#include <bitsery/buffer_writer.h>
+#include <bitsery/buffer_reader.h>
+#include <list>
+#include <bitset>
+
+using testing::Eq;
+using testing::ContainerEq;
+using bitsery::BufferWriter;
+using bitsery::BufferReader;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
+
+struct IntegralTypes {
+    int64_t a;
+    uint32_t b;
+    int16_t c;
+    uint8_t d;
+    int8_t e;
+    int8_t f[2];
+};
+
+IntegralTypes getInitializedIntegralTypes() {
+    IntegralTypes data;
+    data.a = -4894541654564;
+    data.b = 94545646;
+    data.c = -8778;
+    data.d = 200;
+    data.e = -98;
+    data.f[0] = 43;
+    data.f[1] = -45;
+    return data;
+}
+
+void writeIntegralTypesToBuffer(BufferWriter& bw, const IntegralTypes& data) {
+    bw.writeBytes<4>(data.b);
+    bw.writeBytes<1>(data.f[0]);
+    bw.writeBytes<2>(data.c);
+    bw.writeBytes<1>(data.d);
+    bw.writeBytes<8>(data.a);
+    bw.writeBytes<1>(data.e);
+    bw.writeBytes<1>(data.f[1]);
+}
+
+
+TEST(BufferBytesOperations, WriteAndReadBytes) {
+    //setup data
+    auto data =getInitializedIntegralTypes();
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    writeIntegralTypesToBuffer(bw, data);
+
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(18));
+    //read from buffer
+    BufferReader br{buf};
+    IntegralTypes res{};
+    EXPECT_THAT(br.readBytes<4>(res.b), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[0]), Eq(true));
+    EXPECT_THAT(br.readBytes<2>(res.c), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.d), Eq(true));
+    EXPECT_THAT(br.readBytes<8>(res.a), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.e), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[1]), Eq(true));
+    //assert results
+
+    EXPECT_THAT(data.a, Eq(res.a));
+    EXPECT_THAT(data.b, Eq(res.b));
+    EXPECT_THAT(data.c, Eq(res.c));
+    EXPECT_THAT(data.d, Eq(res.d));
+    EXPECT_THAT(data.e, Eq(res.e));
+    EXPECT_THAT(data.f, ContainerEq(res.f));
+
+}
+
+TEST(BufferBytesOperations, BufferReaderUsingDataPlusSizeCtor) {
+    //setup data
+    auto data =getInitializedIntegralTypes();
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    writeIntegralTypesToBuffer(bw, data);
+
+    EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(18));
+    //read from buffer
+    BufferReader br{buf.data(), buf.size()};
+    IntegralTypes res{};
+    EXPECT_THAT(br.readBytes<4>(res.b), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[0]), Eq(true));
+    EXPECT_THAT(br.readBytes<2>(res.c), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.d), Eq(true));
+    EXPECT_THAT(br.readBytes<8>(res.a), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.e), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[1]), Eq(true));
+    //assert results
+
+    EXPECT_THAT(data.a, Eq(res.a));
+    EXPECT_THAT(data.b, Eq(res.b));
+    EXPECT_THAT(data.c, Eq(res.c));
+    EXPECT_THAT(data.d, Eq(res.d));
+    EXPECT_THAT(data.e, Eq(res.e));
+    EXPECT_THAT(data.f, ContainerEq(res.f));
+}
+
+TEST(BufferBytesOperations, BufferReaderUsingCArrayCtor) {
+    //setup data
+    auto data =getInitializedIntegralTypes();
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    writeIntegralTypesToBuffer(bw, data);
+
+    ASSERT_THAT(std::distance(buf.begin(), buf.end()), Eq(18));
+    uint8_t cArrBuf[18];
+    std::copy(buf.begin(), buf.end(), cArrBuf);
+    //read from buffer
+    BufferReader br{cArrBuf};
+    IntegralTypes res{};
+    EXPECT_THAT(br.readBytes<4>(res.b), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[0]), Eq(true));
+    EXPECT_THAT(br.readBytes<2>(res.c), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.d), Eq(true));
+    EXPECT_THAT(br.readBytes<8>(res.a), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.e), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.f[1]), Eq(true));
+    //assert results
+
+    EXPECT_THAT(data.a, Eq(res.a));
+    EXPECT_THAT(data.b, Eq(res.b));
+    EXPECT_THAT(data.c, Eq(res.c));
+    EXPECT_THAT(data.d, Eq(res.d));
+    EXPECT_THAT(data.e, Eq(res.e));
+    EXPECT_THAT(data.f, ContainerEq(res.f));
+}
+
+
+
+TEST(BufferBytesOperations, ReadReturnsFalseIfNotEnoughBufferSize) {
+    //setup data
+    uint8_t a = 111;
+
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+
+    bw.writeBytes<1>(a);
+    bw.writeBytes<1>(a);
+    bw.writeBytes<1>(a);
+    //read from buffer
+    BufferReader br{buf};
+    int16_t b;
+    int32_t c;
+    EXPECT_THAT(br.readBytes<4>(c), Eq(false));
+    EXPECT_THAT(br.readBytes<2>(b), Eq(true));
+    EXPECT_THAT(br.readBytes<2>(b), Eq(false));
+    EXPECT_THAT(br.readBytes<1>(a), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(a), Eq(false));
+    EXPECT_THAT(br.readBytes<2>(b), Eq(false));
+    EXPECT_THAT(br.readBytes<4>(c), Eq(false));
+
+}
+
+
+TEST(BufferBytesOperations, ReadIsCompletedWhenAllBytesAreRead) {
+    //setup data
+    IntegralTypes data;
+    data.b = 94545646;
+    data.c = -8778;
+    data.d = 200;
+
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+
+    bw.writeBytes<4>(data.b);
+    bw.writeBytes<2>(data.c);
+    bw.writeBytes<1>(data.d);
+    //read from buffer
+    BufferReader br{buf};
+    IntegralTypes res;
+    EXPECT_THAT(br.readBytes<4>(res.b), Eq(true));
+    EXPECT_THAT(br.readBytes<2>(res.c), Eq(true));
+    EXPECT_THAT(br.isCompleted(), Eq(false));
+    EXPECT_THAT(br.readBytes<1>(res.d), Eq(true));
+    EXPECT_THAT(br.isCompleted(), Eq(true));
+    EXPECT_THAT(br.readBytes<1>(res.d), Eq(false));
+    EXPECT_THAT(br.isCompleted(), Eq(true));
+
+    BufferReader br1{buf};
+    EXPECT_THAT(br1.readBytes<4>(res.b), Eq(true));
+    EXPECT_THAT(br1.readBytes<2>(res.c), Eq(true));
+    EXPECT_THAT(br1.isCompleted(), Eq(false));
+    EXPECT_THAT(br1.readBytes<2>(res.c), Eq(false));
+    EXPECT_THAT(br1.isCompleted(), Eq(false));
+    EXPECT_THAT(br1.readBytes<1>(res.d), Eq(true));
+    EXPECT_THAT(br1.isCompleted(), Eq(true));
+
+}
+
+TEST(BufferBytesOperations, ReadWriteBufferFncCanAcceptSignedData) {
+    //setup data
+    constexpr size_t DATA_SIZE = 3;
+    int16_t src[DATA_SIZE] {54,-4877,30067};
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    bw.writeBuffer<2>(src, DATA_SIZE);
+    bw.flush();
+    //read from buffer
+    BufferReader br1{buf};
+    int16_t dst[DATA_SIZE]{};
+    EXPECT_THAT(br1.readBuffer<2>(dst, DATA_SIZE), Eq(true));
+    EXPECT_THAT(dst, ContainerEq(src));
+
+    //read more than available
+    BufferReader br2{buf};
+    int16_t dstMore[DATA_SIZE+1]{};
+    EXPECT_THAT(br2.readBuffer<2>(dstMore, DATA_SIZE+1), Eq(false));
+}
+
+TEST(BufferBytesOperations, ReadWriteBufferCanWorkOnUnalignedData) {
+    //setup data
+    constexpr size_t DATA_SIZE = 3;
+    int16_t src[DATA_SIZE] {54,-4877,30067};
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    bw.writeBits(15u, 4);
+    bw.writeBuffer<2>(src, DATA_SIZE);
+    bw.writeBits(12u, 4);
+    bw.flush();
+    EXPECT_THAT(buf.size(), Eq(sizeof(src) + 1));
+
+    //read from buffer
+    BufferReader br1{buf};
+    int16_t dst[DATA_SIZE]{};
+    uint8_t tmp{};
+    br1.readBits(tmp, 4);
+    EXPECT_THAT(tmp, Eq(15));
+    EXPECT_THAT(br1.readBuffer<2>(dst, DATA_SIZE), Eq(true));
+    EXPECT_THAT(dst, ContainerEq(src));
+    br1.readBits(tmp, 4);
+    EXPECT_THAT(tmp, Eq(12));
+
+    //read more than available
+    BufferReader br2{buf};
+    br2.readBits(tmp, 4);
+    int16_t dstMore[DATA_SIZE+1]{};
+    EXPECT_THAT(tmp, Eq(15));
+    EXPECT_THAT(br2.readBuffer<2>(dstMore, DATA_SIZE+1), Eq(false));
+}
+

tests/buffer_endianness.cpp

@@ -22,15 +22,15 @@
 
 
 #include <gmock/gmock.h>
-#include <bitsery/adapter_writer.h>
-#include <bitsery/adapter_reader.h>
-#include <bitsery/ext/value_range.h>
-#include "serialization_test_utils.h"
+#include <bitsery/buffer_writer.h>
+#include <bitsery/buffer_reader.h>
+#include <bitsery/details/serialization_common.h>
 
 using testing::Eq;
 using testing::ContainerEq;
 using bitsery::EndiannessType;
 using bitsery::DefaultConfig;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
 
 constexpr EndiannessType getInverseEndianness(EndiannessType e) {
     return e == EndiannessType::LittleEndian
@@ -38,8 +38,10 @@ constexpr EndiannessType getInverseEndianness(EndiannessType e) {
            : EndiannessType::LittleEndian;
 }
 
-struct InverseEndiannessConfig:public DefaultConfig {
+struct InverseEndiannessConfig {
     static constexpr bitsery::EndiannessType NetworkEndianness = getInverseEndianness(DefaultConfig::NetworkEndianness);
+    using BufferValueType = DefaultConfig::BufferValueType;
+    using BufferScrathType = DefaultConfig::BufferScrathType;
 };
 
 struct IntegralTypes {
@@ -50,29 +52,27 @@ struct IntegralTypes {
     int8_t e;
 };
 
-using InverseReader = bitsery::AdapterReader<InputAdapter, InverseEndiannessConfig>;
 
-
-TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
+TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
     //fill initial values
     IntegralTypes src{};
-    src.a = static_cast<int64_t>(0x1122334455667788);
+    src.a = 0x1122334455667788;
     src.b = 0xBBCCDDEE;
-    src.c = static_cast<int16_t>(0xCCDD);
-    src.d = static_cast<uint8_t>(0xDD);
-    src.e = static_cast<int8_t>(0xEE);
+    src.c = 0xCCDD;
+    src.d = 0xDD;
+    src.e = 0xEE;
 
     //fill expected result after swap
     IntegralTypes resInv{};
-    resInv.a = static_cast<int64_t>(0x8877665544332211);
+    resInv.a = 0x8877665544332211;
     resInv.b = 0xEEDDCCBB;
-    resInv.c = static_cast<int16_t>(0xDDCC);
-    resInv.d = static_cast<uint8_t>(0xDD);
-    resInv.e = static_cast<int8_t>(0xEE);
+    resInv.c = 0xDDCC;
+    resInv.d = 0xDD;
+    resInv.e = 0xEE;
 
     //create and write to buffer
     Buffer buf{};
-    Writer bw{buf};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
     bw.writeBytes<8>(src.a);
     bw.writeBytes<4>(src.b);
     bw.writeBytes<2>(src.c);
@@ -80,7 +80,7 @@ TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
     bw.writeBytes<1>(src.e);
     bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
     IntegralTypes res{};
     br.readBytes<8>(res.a);
     br.readBytes<4>(res.b);
@@ -95,25 +95,25 @@ TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
     EXPECT_THAT(res.e, Eq(resInv.e));
 }
 
-TEST(DataEndianness, WhenWrite1ByteValuesThenEndiannessIsIgnored) {
+TEST(BufferEndianness, WhenWriteBuffer1ByteValuesThenEndiannessIsIgnored) {
     //fill initial values
     constexpr size_t SIZE = 4;
     uint8_t src[SIZE] = {0xAA, 0xBB, 0xCC, 0xDD};
     uint8_t res[SIZE] = {};
     //create and write to buffer
     Buffer buf{};
-    Writer bw{buf};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
     bw.writeBuffer<1>(src, SIZE);
     bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
     br.readBuffer<1>(res, SIZE);
     //result is identical, because we write separate values, of size 1byte, that requires no swapping
     //check results
     EXPECT_THAT(res, ContainerEq(src));
 }
 
-TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
+TEST(BufferEndianness, WhenWriteBufferMoreThan1ByteValuesThenValuesAreSwapped) {
     //fill initial values
     constexpr size_t SIZE = 4;
     uint16_t src[SIZE] = {0xAA00, 0xBB11, 0xCC22, 0xDD33};
@@ -121,11 +121,11 @@ TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
     uint16_t res[SIZE] = {};
     //create and write to buffer
     Buffer buf{};
-    Writer bw{buf};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
     bw.writeBuffer<2>(src, SIZE);
     bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
     br.readBuffer<2>(res, SIZE);
     //result is identical, because we write separate values, of size 1byte, that requires no swapping
     //check results
@@ -136,7 +136,7 @@ TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
 template <typename T>
 constexpr size_t getBits(T v) {
     return bitsery::details::calcRequiredBits<T>({}, v);
-}
+};
 
 struct IntegralUnsignedTypes {
     uint64_t a;
@@ -145,13 +145,15 @@ struct IntegralUnsignedTypes {
     uint8_t d;
 };
 
-TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
+TEST(BufferEndianness, WhenBufferValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
+    //fill initial values
+    static_assert(sizeof(DefaultConfig::BufferValueType) == 1, "currently only 1 byte size, value size is supported");
     //fill initial values
     constexpr IntegralUnsignedTypes src {
-            0x0000334455667788,
-            0x00CCDDEE,
-            0x00DD,
-            0x0F,
+            0x0000334455667788,//bits 19
+            0x00CCDDEE,//bits 16
+            0x00DD,//bits 1
+            0x0F,//bits 6
     };
 
     constexpr size_t aBITS = getBits(src.a) + 8;
@@ -160,21 +162,19 @@ TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndiann
     constexpr size_t dBITS = getBits(src.d) + 2;
     //create and write to buffer
     Buffer buf{};
-    Writer bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<Writer> bpw{bw};
-    bpw.writeBits(src.a, aBITS);
-    bpw.writeBits(src.b, bBITS);
-    bpw.writeBits(src.c, cBITS);
-    bpw.writeBits(src.d, dBITS);
-    bpw.flush();
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
+    bw.writeBits(src.a, aBITS);
+    bw.writeBits(src.b, bBITS);
+    bw.writeBits(src.c, cBITS);
+    bw.writeBits(src.d, dBITS);
+    bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
-    bitsery::AdapterReaderBitPackingWrapper<InverseReader> bpr{br};
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
     IntegralUnsignedTypes res{};
-    bpr.readBits(res.a, aBITS);
-    bpr.readBits(res.b, bBITS);
-    bpr.readBits(res.c, cBITS);
-    bpr.readBits(res.d, dBITS);
+    br.readBits(res.a, aBITS);
+    br.readBits(res.b, bBITS);
+    br.readBits(res.c, cBITS);
+    br.readBits(res.d, dBITS);
     //check results
     EXPECT_THAT(res.a, Eq(src.a));
     EXPECT_THAT(res.b, Eq(src.b));

tests/data_operations.cpp

@@ -1,407 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <bitsery/ext/value_range.h>
-
-using testing::Eq;
-using testing::ContainerEq;
-
-using AdapterBitPackingWriter = bitsery::AdapterWriterBitPackingWrapper<Writer>;
-using AdapterBitPackingReader = bitsery::AdapterReaderBitPackingWrapper<Reader>;
-
-
-struct IntegralUnsignedTypes {
-    uint32_t a;
-    uint16_t b;
-    uint8_t c;
-    uint8_t d;
-    uint64_t e;
-};
-
-template <typename T>
-constexpr size_t getBits(T v) {
-    return bitsery::details::calcRequiredBits<T>({}, v);
-}
-
-// *** bits operations
-
-TEST(DataBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
-    Buffer buf;
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-    bpw.writeBits(std::numeric_limits<uint64_t>::max(), 64);
-    bpw.writeBits(std::numeric_limits<uint32_t>::max(), 32);
-    bpw.writeBits(std::numeric_limits<uint16_t>::max(), 16);
-    bpw.writeBits(std::numeric_limits<uint8_t>::max(), 8);
-    bpw.flush();
-
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
-    AdapterBitPackingReader bpr{br};
-    uint64_t v64{};
-    uint32_t v32{};
-    uint16_t v16{};
-    uint8_t v8{};
-    bpr.readBits(v64, 64);
-    bpr.readBits(v32, 32);
-    bpr.readBits(v16, 16);
-    bpr.readBits(v8, 8);
-
-    EXPECT_THAT(v64, Eq(std::numeric_limits<uint64_t>::max()));
-    EXPECT_THAT(v32, Eq(std::numeric_limits<uint32_t>::max()));
-    EXPECT_THAT(v16, Eq(std::numeric_limits<uint16_t>::max()));
-    EXPECT_THAT(v8, Eq(std::numeric_limits<uint8_t>::max()));
-}
-
-TEST(DataBitsAndBytesOperations, WriteAndReadBits) {
-    //setup data
-    constexpr IntegralUnsignedTypes data{
-        485454,//bits 19
-        45978,//bits 16
-        0,//bits 1
-        36,//bits 6
-        479845648946//bits 39
-    };
-
-    constexpr size_t aBITS = getBits(data.a) + 2;
-    constexpr size_t bBITS = getBits(data.b) + 0;
-    constexpr size_t cBITS = getBits(data.c) + 2;
-    constexpr size_t dBITS = getBits(data.d) + 1;
-    constexpr size_t eBITS = getBits(data.e) + 8;
-
-    //create and write to buffer
-    Buffer buf;
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-
-    bpw.writeBits(data.a, aBITS);
-    bpw.writeBits(data.b, bBITS);
-    bpw.writeBits(data.c, cBITS);
-    bpw.writeBits(data.d, dBITS);
-    bpw.writeBits(data.e, eBITS);
-    bpw.flush();
-    auto writtenSize = bpw.writtenBytesCount();
-    auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
-    EXPECT_THAT(writtenSize, Eq(bytesCount));
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr{br};
-
-    IntegralUnsignedTypes res{};
-
-    bpr.readBits(res.a, aBITS);
-    bpr.readBits(res.b, bBITS);
-    bpr.readBits(res.c, cBITS);
-    bpr.readBits(res.d, dBITS);
-    bpr.readBits(res.e, eBITS);
-
-    EXPECT_THAT(res.a, Eq(data.a));
-    EXPECT_THAT(res.b, Eq(data.b));
-    EXPECT_THAT(res.c, Eq(data.c));
-    EXPECT_THAT(res.d, Eq(data.d));
-    EXPECT_THAT(res.e, Eq(data.e));
-
-}
-
-TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
-    //setup data
-
-    //create and write to buffer
-    Buffer buf;
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-
-    bpw.writeBits(7u,3);
-    bpw.flush();
-    auto writtenSize = bpw.writtenBytesCount();
-    EXPECT_THAT(writtenSize, Eq(1));
-
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr{br};
-    uint16_t tmp;
-    bpr.readBits(tmp,4);
-    bpr.readBits(tmp,2);
-    bpr.readBits(tmp,2);
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
-    bpr.readBits(tmp,2);
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::DataOverflow));//false
-
-    //part of next byte
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr1{br1};
-    bpr1.readBits(tmp,2);
-    EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::NoError));
-    bpr1.readBits(tmp,7);
-    EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::DataOverflow));//false
-
-    //bigger than byte
-    Reader br2{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr2{br2};
-    bpr2.readBits(tmp,9);
-    EXPECT_THAT(bpr2.error(), Eq(bitsery::ReaderError::DataOverflow));//false
-}
-
-TEST(DataBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
-    Buffer buf;
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-
-    bpw.writeBits(3u, 2);
-    //3 calls to align after 1st data
-    bpw.align();
-    bpw.align();
-    bpw.align();
-    bpw.writeBits(7u, 3);
-    //1 call to align after 2nd data
-    bpw.align();
-    bpw.writeBits(15u, 4);
-    bpw.flush();
-
-    unsigned char tmp;
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
-    AdapterBitPackingReader bpr{br};
-    bpr.readBits(tmp,2);
-    EXPECT_THAT(tmp, Eq(3u));
-    bpr.align();
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
-    bpr.readBits(tmp,3);
-    bpr.align();
-    bpr.align();
-    bpr.align();
-    EXPECT_THAT(tmp, Eq(7u));
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
-
-    bpr.readBits(tmp,4);
-    EXPECT_THAT(tmp, Eq(15u));
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
-}
-
-TEST(DataBitsAndBytesOperations, AlignWritesZerosBits) {
-    //setup data
-
-    //create and write to buffer
-    Buffer buf;
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-
-    //write 2 bits and align
-    bpw.writeBits(3u, 2);
-    bpw.align();
-    bpw.flush();
-    auto writtenSize = bpw.writtenBytesCount();
-    EXPECT_THAT(writtenSize, Eq(1));
-    unsigned char tmp;
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr1{br1};
-    bpr1.readBits(tmp,2);
-    //read aligned bits
-    bpr1.readBits(tmp,6);
-    EXPECT_THAT(tmp, Eq(0));
-
-    Reader br2{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr2{br2};
-    //read 2 bits
-    bpr2.readBits(tmp,2);
-    bpr2.align();
-    EXPECT_THAT(bpr2.error(), Eq(bitsery::ReaderError::NoError));
-}
-
-
-// *** bytes operations
-
-struct IntegralTypes {
-    int64_t a;
-    uint32_t b;
-    int16_t c;
-    uint8_t d;
-    int8_t e;
-    int8_t f[2];
-};
-
-TEST(DataBitsAndBytesOperations, WriteAndReadBytes) {
-    //setup data
-    IntegralTypes data;
-    data.a = -4894541654564;
-    data.b = 94545646;
-    data.c = -8778;
-    data.d = 200;
-    data.e = -98;
-    data.f[0] = 43;
-    data.f[1] = -45;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-    bw.writeBytes<4>(data.b);
-    bw.writeBytes<2>(data.c);
-    bw.writeBytes<1>(data.d);
-    bw.writeBytes<8>(data.a);
-    bw.writeBytes<1>(data.e);
-    bw.writeBuffer<1>(data.f, 2);
-    bw.flush();
-    auto writtenSize = bw.writtenBytesCount();
-
-    EXPECT_THAT(writtenSize, Eq(18));
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
-    IntegralTypes res{};
-    br.readBytes<4>(res.b);
-    br.readBytes<2>(res.c);
-    br.readBytes<1>(res.d);
-    br.readBytes<8>(res.a);
-    br.readBytes<1>(res.e);
-    br.readBuffer<1>(res.f, 2);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
-    //assert results
-
-    EXPECT_THAT(data.a, Eq(res.a));
-    EXPECT_THAT(data.b, Eq(res.b));
-    EXPECT_THAT(data.c, Eq(res.c));
-    EXPECT_THAT(data.d, Eq(res.d));
-    EXPECT_THAT(data.e, Eq(res.e));
-    EXPECT_THAT(data.f, ContainerEq(res.f));
-
-}
-
-TEST(DataBitsAndBytesOperations, WriteAndReadBytesWithBitPackingWrapper) {
-    //setup data
-    IntegralTypes data;
-    data.a = -4894541654564;
-    data.b = 94545646;
-    data.c = -8778;
-    data.d = 200;
-    data.e = -98;
-    data.f[0] = 43;
-    data.f[1] = -45;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-    bpw.writeBytes<4>(data.b);
-    bpw.writeBytes<2>(data.c);
-    bpw.writeBytes<1>(data.d);
-    bpw.writeBytes<8>(data.a);
-    bpw.writeBytes<1>(data.e);
-    bpw.writeBuffer<1>(data.f, 2);
-    bpw.flush();
-    auto writtenSize = bpw.writtenBytesCount();
-
-    EXPECT_THAT(writtenSize, Eq(18));
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr{br};
-    IntegralTypes res{};
-    bpr.readBytes<4>(res.b);
-    bpr.readBytes<2>(res.c);
-    bpr.readBytes<1>(res.d);
-    bpr.readBytes<8>(res.a);
-    bpr.readBytes<1>(res.e);
-    bpr.readBuffer<1>(res.f, 2);
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
-    //assert results
-
-    EXPECT_THAT(data.a, Eq(res.a));
-    EXPECT_THAT(data.b, Eq(res.b));
-    EXPECT_THAT(data.c, Eq(res.c));
-    EXPECT_THAT(data.d, Eq(res.d));
-    EXPECT_THAT(data.e, Eq(res.e));
-    EXPECT_THAT(data.f, ContainerEq(res.f));
-
-}
-
-TEST(DataBitsAndBytesOperations, ReadWriteFncCanAcceptSignedData) {
-    //setup data
-    constexpr size_t DATA_SIZE = 3;
-    int16_t src[DATA_SIZE] {54,-4877,30067};
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-    bw.writeBuffer<2>(src, DATA_SIZE);
-    bw.flush();
-    //read from buffer
-    Reader br1{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    int16_t dst[DATA_SIZE]{};
-    br1.readBuffer<2>(dst, DATA_SIZE);
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(dst, ContainerEq(src));
-}
-
-TEST(DataBitsAndBytesOperations, ReadWriteCanWorkOnUnalignedData) {
-    //setup data
-    constexpr size_t DATA_SIZE = 3;
-    int16_t src[DATA_SIZE] {54,-4877,30067};
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-    bpw.writeBits(15u, 4);
-    bpw.writeBuffer<2>(src, DATA_SIZE);
-    bpw.writeBits(12u, 4);
-    bpw.flush();
-    auto writtenSize = bpw.writtenBytesCount();
-    EXPECT_THAT(writtenSize, Eq(sizeof(src) + 1));
-
-    //read from buffer
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
-    AdapterBitPackingReader bpr1{br1};
-    int16_t dst[DATA_SIZE]{};
-    uint8_t tmp{};
-    bpr1.readBits(tmp, 4);
-    EXPECT_THAT(tmp, Eq(15));
-    bpr1.readBuffer<2>(dst, DATA_SIZE);
-    EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(dst, ContainerEq(src));
-    bpr1.readBits(tmp, 4);
-    EXPECT_THAT(tmp, Eq(12));
-}
-
-TEST(DataBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZeroBits) {
-    //setup data
-    int16_t data[2]{0x0000, 0x7FFF};
-    int16_t res[2]{};
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-    AdapterBitPackingWriter bpw{bw};
-    bpw.writeBits(2u, 2);
-    bpw.writeBytes<2>(data[0]);
-    bpw.writeBytes<2>(data[1]);
-    bpw.align();
-    bpw.flush();
-
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
-    AdapterBitPackingReader bpr{br};
-    uint8_t tmp{};
-    bpr.readBits(tmp, 2);
-    EXPECT_THAT(tmp, Eq(2));
-    bpr.readBytes<2>(res[0]);
-    bpr.readBytes<2>(res[1]);
-    bpr.align();
-    EXPECT_THAT(res[0], Eq(data[0]));
-    EXPECT_THAT(res[1], Eq(data[1]));
-}
-

tests/data_reading.cpp

@@ -1,155 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <list>
-#include <bitset>
-
-using testing::Eq;
-
-struct IntegralTypes {
-    int64_t a;
-    uint32_t b;
-    int16_t c;
-    uint8_t d;
-    int8_t e;
-    int8_t f[2];
-};
-
-TEST(DataReading, WhenReadingMoreThanAvailableThenEmptyBufferError) {
-    //setup data
-    uint8_t a = 111;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.flush();
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    int32_t c;
-    br.readBytes<4>(c);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
-}
-
-TEST(DataReading, WhenErrorOccursThenAllOtherOperationsFailsForSameError) {
-    //setup data
-    uint8_t a = 111;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.flush();
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    int32_t c;
-    br.readBytes<4>(c);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
-    br.readBytes<1>(a);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
-}
-
-
-TEST(DataReading, ReadIsCompletedSuccessfullyWhenAllBytesAreReadWithoutErrors) {
-    //setup data
-    IntegralTypes data;
-    data.b = 94545646;
-    data.c = -8778;
-    data.d = 200;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-
-    bw.writeBytes<4>(data.b);
-    bw.writeBytes<2>(data.c);
-    bw.writeBytes<1>(data.d);
-    bw.flush();
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    IntegralTypes res;
-    br.readBytes<4>(res.b);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
-    br.readBytes<2>(res.c);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
-    br.readBytes<1>(res.d);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(true));
-    br.readBytes<1>(res.d);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
-    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
-
-    Reader br1{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    br1.readBytes<4>(res.b);
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
-    br1.readBytes<2>(res.c);
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
-    EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
-    br1.readBytes<2>(res.c);
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::DataOverflow));
-    EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
-    br1.readBytes<1>(res.d);
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::DataOverflow));
-    EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
-}
-
-TEST(DataReading, WhenReaderHasErrorsAllOperationsReadsReturnZero) {
-    //setup data
-    uint8_t a = 111;
-
-    //create and write to buffer
-    Buffer buf{};
-    Writer bw{buf};
-
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.writeBytes<1>(a);
-    bw.flush();
-    //read from buffer
-    Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    bitsery::AdapterReaderBitPackingWrapper<Reader> bpr{br};
-    int32_t c;
-    bpr.readBytes<4>(c);
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
-
-    int16_t r1= {-645};
-    uint32_t r2[2] = {54898,87854};
-    uint8_t r3 = 0xFF;
-
-    bpr.readBytes<2>(r1);
-    bpr.readBuffer<4>(r2, 2);
-    bpr.readBits(r3, 7);
-    EXPECT_THAT(r1, Eq(0));
-    EXPECT_THAT(r2[0], Eq(0u));
-    EXPECT_THAT(r2[1], Eq(0u));
-    EXPECT_THAT(r3, Eq(0u));
-}

tests/data_reading_errors.cpp

@@ -1,135 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <bitsery/traits/string.h>
-
-using testing::Eq;
-using SessionsEnabledWriter = bitsery::AdapterWriter<OutputAdapter, SessionsEnabledConfig>;
-using SessionsEnabledReader = bitsery::AdapterReader<InputAdapter, SessionsEnabledConfig>;
-
-TEST(DataReadingErrors, WhenContainerOrTextSizeIsMoreThanMaxThenInvalidDataError) {
-    SerializationContext ctx;
-    std::string tmp = "larger text then allowed";
-    ctx.createSerializer().text1b(tmp,100);
-    ctx.createDeserializer().text1b(tmp, 10);
-    EXPECT_THAT(ctx.br->error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-TEST(DataReadingErrors, WhenReadingBoolByteReadsMoreThanOneThenInvalidBufferDataErrorAndResultIsFalse) {
-    SerializationContext ctx;
-    auto& ser = ctx.createSerializer();
-    ser.value1b(uint8_t{1});
-    ser.value1b(uint8_t{2});
-    bool res{};
-    auto& des = ctx.createDeserializer();
-    des.boolValue(res);
-    EXPECT_THAT(res, Eq(true));
-    des.boolValue(res);
-    EXPECT_THAT(res, Eq(false));
-    EXPECT_THAT(ctx.br->error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-TEST(DataReadingErrors, WhenReadingAlignHasNonZerosThenInvalidDataError) {
-    Buffer buf{};
-    Writer bw{buf};
-    uint8_t tmp{0xFF};
-    bw.writeBytes<1>(tmp);
-    bw.flush();
-
-    Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    bitsery::AdapterReaderBitPackingWrapper<Reader> bpr{br};
-
-    bpr.readBits(tmp,3);
-    bpr.align();
-    EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-TEST(DataReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidDataError) {
-    uint8_t tmp{0xFF};
-    Buffer buf{};
-    SessionsEnabledWriter bw{buf};
-    for (auto i = 0; i < 2; ++i) {
-        bw.beginSession();
-        bw.writeBytes<1>(tmp);
-        bw.writeBytes<1>(tmp);
-        bw.endSession();
-    }
-    bw.flush();
-    SessionsEnabledReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    for (auto i = 0; i < 2; ++i) {
-        br.beginSession();
-        br.readBytes<1>(tmp);
-        br.beginSession();
-        br.readBytes<1>(tmp);
-        br.endSession();
-        br.endSession();
-    }
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-
-TEST(DataReadingErrors, WhenInitializingSessionsWhenNotEnoughDataThenInvalidData) {
-    uint8_t tmp1{0xFF};
-    Buffer buf1{};
-    SessionsEnabledWriter bw1{buf1};
-    bw1.writeBytes<1>(tmp1);
-    bw1.flush();
-    SessionsEnabledReader br1{InputAdapter{buf1.begin(), bw1.writtenBytesCount()}};
-    br1.beginSession();
-    EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::InvalidData));
-
-    Buffer buf2{};
-    SessionsEnabledWriter bw2{buf2};
-    uint16_t tmp2{0x8000};
-    bw2.writeBytes<2>(tmp2);
-    bw2.flush();
-    SessionsEnabledReader br2{InputAdapter{buf2.begin(), bw2.writtenBytesCount()}};
-    br2.beginSession();
-    EXPECT_THAT(br2.error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-TEST(DataReadingErrors, WhenInitializingSessionsWhereSessionsDataOffsetIsCorruptedThenInvalidData) {
-    Buffer buf{};
-    SessionsEnabledWriter bw{buf};
-    bw.writeBytes<1>(uint8_t{1});
-    bw.writeBytes<1>(uint8_t{1});
-    bw.writeBytes<4>(uint32_t{10});
-    SessionsEnabledReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    br.beginSession();
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::InvalidData));
-}
-
-TEST(DataReadingErrors, WhenReadingNewSessionOutsideSessionThenInvalidData) {
-    Buffer buf{};
-    SessionsEnabledWriter bw{buf};
-    bw.beginSession();
-    bw.writeBytes<1>(uint8_t{1});
-    bw.endSession();
-    bw.flush();
-    SessionsEnabledReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
-    br.beginSession();
-    br.endSession();
-    br.beginSession();
-    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::InvalidData));
-}

tests/data_writing.cpp

@@ -1,110 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <bitsery/details/serialization_common.h>
-#include <bitsery/traits/array.h>
-
-using testing::Eq;
-using testing::ContainerEq;
-using bitsery::EndiannessType;
-
-template <typename BufType>
-class DataWriting:public testing::Test {
-public:
-    using TWriter = bitsery::AdapterWriter<bitsery::OutputBufferAdapter<BufType>, bitsery::DefaultConfig>;
-    using TBuffer = BufType;
-};
-
-using NonFixedContainer = std::vector<uint8_t>;
-using FixedContainer = std::array<uint8_t, 100>;
-
-using ContainerTypes = ::testing::Types<FixedContainer,NonFixedContainer>;
-
-TYPED_TEST_CASE(DataWriting, ContainerTypes);
-
-static constexpr size_t DATA_SIZE = 14u;
-
-template <typename BW>
-void writeData(BW& bw) {
-    uint16_t tmp1{45}, tmp2{6543}, tmp3{46533};
-    uint32_t tmp4{8979445}, tmp5{7987564};
-    bw.template writeBytes<2>(tmp1);
-    bw.template writeBytes<2>(tmp2);
-    bw.template writeBytes<2>(tmp3);
-    bw.template writeBytes<4>(tmp4);
-    bw.template writeBytes<4>(tmp5);
-}
-
-TYPED_TEST(DataWriting, GetWrittenBytesCountReturnsActualBytesWritten) {
-    using TWriter = typename TestFixture::TWriter;
-    using TBuffer = typename TestFixture::TBuffer;
-    TBuffer buf{};
-    TWriter bw{buf};
-    writeData(bw);
-    bw.flush();
-    auto writtenSize = bw.writtenBytesCount();
-    EXPECT_THAT(writtenSize, DATA_SIZE);
-    EXPECT_THAT(buf.size(), ::testing::Ge(DATA_SIZE));
-}
-
-TYPED_TEST(DataWriting, WhenWritingBitsThenMustFlushWriter) {
-    using TWriter = typename TestFixture::TWriter;
-    using TBuffer = typename TestFixture::TBuffer;
-    TBuffer buf{};
-    TWriter bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
-    bpw.writeBits(3u, 2);
-    auto writtenSize1 = bpw.writtenBytesCount();
-    bpw.flush();
-    auto writtenSize2 = bpw.writtenBytesCount();
-    EXPECT_THAT(writtenSize1, Eq(0));
-    EXPECT_THAT(writtenSize2, Eq(1));
-}
-
-TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
-    using TWriter = typename TestFixture::TWriter;
-    using TBuffer = typename TestFixture::TBuffer;
-    TBuffer buf{};
-    TWriter bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
-    bpw.writeBits(3u, 2);
-    bpw.align();
-    auto writtenSize1 = bpw.writtenBytesCount();
-    bpw.flush();
-    auto writtenSize2 = bpw.writtenBytesCount();
-    EXPECT_THAT(writtenSize1, Eq(1));
-    EXPECT_THAT(writtenSize2, Eq(1));
-
-}
-
-TEST(DataWritingNonFixedBufferContainer, ContainerIsAlwaysResizedToCapacity) {
-    NonFixedContainer buf{};
-    bitsery::AdapterWriter<bitsery::OutputBufferAdapter<NonFixedContainer>, bitsery::DefaultConfig> bw{buf};
-    for (auto i = 0; i < 5; ++i) {
-        uint32_t tmp{};
-        bw.writeBytes<4>(tmp);
-        bw.writeBytes<4>(tmp);
-        EXPECT_TRUE(buf.size() == buf.capacity());
-    }
-}

tests/flexible_syntax.cpp

@@ -1,386 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <bitsery/flexible.h>
-
-#include <bitsery/flexible/string.h>
-#include <bitsery/flexible/array.h>
-#include <bitsery/flexible/vector.h>
-#include <bitsery/flexible/list.h>
-#include <bitsery/flexible/forward_list.h>
-#include <bitsery/flexible/deque.h>
-#include <bitsery/flexible/queue.h>
-#include <bitsery/flexible/stack.h>
-#include <bitsery/flexible/map.h>
-#include <bitsery/flexible/unordered_map.h>
-#include <bitsery/flexible/set.h>
-#include <bitsery/flexible/unordered_set.h>
-
-using testing::Eq;
-
-TEST(FlexibleSyntax, FundamentalTypesAndBool) {
-    int ti = 8745;
-    MyEnumClass te = MyEnumClass::E4;
-    float tf = 485.042f;
-    double td = -454184.48445;
-    bool tb=true;
-    SerializationContext ctx{};
-    ctx.createSerializer().archive(ti,te,tf,td,tb);
-
-    //result
-    int ri{};
-    MyEnumClass re{};
-    float rf{};
-    double rd{};
-    bool rb{};
-    ctx.createDeserializer().archive(ri,re,rf,rd,rb);
-
-    //test
-    EXPECT_THAT(ri, Eq(ti));
-    EXPECT_THAT(re, Eq(te));
-    EXPECT_THAT(rf, Eq(tf));
-    EXPECT_THAT(rd, Eq(td));
-    EXPECT_THAT(rb, Eq(tb));
-}
-
-TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
-    int ti = 8745;
-    MyEnumClass te = MyEnumClass::E4;
-    float tf = 485.042f;
-    double td = -454184.48445;
-    bool tb=true;
-    SerializationContext ctx;
-    auto& ser = ctx.createSerializer();
-    ser.object(ti);
-    ser.object(te);
-    ser.object(tf);
-    ser.object(td);
-    ser.object(tb);
-
-    //result
-    int ri{};
-    MyEnumClass re{};
-    float rf{};
-    double rd{};
-    bool rb{};
-    auto& des = ctx.createDeserializer();
-    des.object(ri);
-    des.object(re);
-    des.object(rf);
-    des.object(rd);
-    des.object(rb);
-
-    //test
-    EXPECT_THAT(ri, Eq(ti));
-    EXPECT_THAT(re, Eq(te));
-    EXPECT_THAT(rf, Eq(tf));
-    EXPECT_THAT(rd, Eq(td));
-    EXPECT_THAT(rb, Eq(tb));
-}
-
-TEST(FlexibleSyntax, MixDifferentSyntax) {
-    int ti = 8745;
-    MyEnumClass te = MyEnumClass::E4;
-    float tf = 485.042f;
-    double td = -454184.48445;
-    bool tb=true;
-    SerializationContext ctx;
-    auto& ser = ctx.createSerializer();
-    ser.value<sizeof(ti)>(ti);
-    ser.archive(te, tf, td);
-    ser.object(tb);
-
-    //result
-    int ri{};
-    MyEnumClass re{};
-    float rf{};
-    double rd{};
-    bool rb{};
-    auto& des = ctx.createDeserializer();
-    des.archive(ri, re, rf);
-    des.value8b(rd);
-    des.object(rb);
-
-    //test
-    EXPECT_THAT(ri, Eq(ti));
-    EXPECT_THAT(re, Eq(te));
-    EXPECT_THAT(rf, Eq(tf));
-    EXPECT_THAT(rd, Eq(td));
-    EXPECT_THAT(rb, Eq(tb));
-}
-
-
-template <typename T>
-T procArchive(const T& testData) {
-    SerializationContext ctx;
-    ctx.createSerializer().archive(testData);
-    T res;
-    ctx.createDeserializer().archive(res);
-    return res;
-}
-
-template <typename T>
-T procArchiveWithMaxSize(const T& testData) {
-    SerializationContext ctx;
-    ctx.createSerializer().archive(bitsery::maxSize(testData, 100));
-    T res;
-    ctx.createDeserializer().archive(bitsery::maxSize(res, 100));
-    return res;
-}
-
-TEST(FlexibleSyntax, CStyleArrayForValueTypesAsContainer) {
-    const int t1[3]{8748,-484,45};
-    int r1[3]{0,0,0};
-
-    SerializationContext ctx;
-    ctx.createSerializer().archive(bitsery::asContainer(t1));
-    ctx.createDeserializer().archive(bitsery::asContainer(r1));
-
-    EXPECT_THAT(r1, ::testing::ContainerEq(t1));
-}
-
-TEST(FlexibleSyntax, CStyleArrayForIntegralTypesAsText) {
-    const char t1[3]{"hi"};
-    char r1[3]{0,0,0};
-
-    SerializationContext ctx;
-    ctx.createSerializer().archive(bitsery::asText(t1));
-    ctx.createDeserializer().archive(bitsery::asText(r1));
-
-    EXPECT_THAT(r1, ::testing::ContainerEq(t1));
-}
-
-TEST(FlexibleSyntax, CStyleArray) {
-    const MyEnumClass t1[3]{MyEnumClass::E1, MyEnumClass::E4, MyEnumClass::E2};
-    MyEnumClass r1[3]{};
-
-    SerializationContext ctx;
-    ctx.createSerializer().archive(t1);
-    ctx.createDeserializer().archive(r1);
-
-    EXPECT_THAT(r1, ::testing::ContainerEq(t1));
-}
-
-
-TEST(FlexibleSyntax, StdString) {
-    std::string t1{"my nice string"};
-    std::string t2{};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t2), Eq(t2));
-}
-
-TEST(FlexibleSyntax, StdArray) {
-    std::array<int, 3> t1{8748,-484,45};
-    std::array<int, 0> t2{};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-
-}
-
-TEST(FlexibleSyntax, StdVector) {
-    std::vector<int> t1{8748,-484,45};
-    std::vector<float> t2{5.f,0.198f};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t2), Eq(t2));
-
-}
-
-TEST(FlexibleSyntax, StdList) {
-    std::list<int> t1{8748,-484,45};
-    std::list<float> t2{5.f,0.198f};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t2), Eq(t2));
-
-}
-
-TEST(FlexibleSyntax, StdForwardList) {
-    std::forward_list<int> t1{8748,-484,45};
-    std::forward_list<float> t2{5.f,0.198f};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t2), Eq(t2));
-
-}
-
-TEST(FlexibleSyntax, StdDeque) {
-    std::deque<int> t1{8748,-484,45};
-    std::deque<float> t2{5.f,0.198f};
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchive(t2), Eq(t2));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t2), Eq(t2));
-
-}
-
-TEST(FlexibleSyntax, StdQueue) {
-    std::queue<std::string> t1;
-    t1.push("first");
-    t1.push("second string");
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-
-}
-
-TEST(FlexibleSyntax, StdPriorityQueue) {
-    std::priority_queue<std::string> t1;
-    t1.push("first");
-    t1.push("second string");
-    t1.push("third");
-    t1.push("fourth");
-    auto r1 = procArchive(t1);
-    //we cannot compare priority queue directly
-
-    EXPECT_THAT(r1.size(), Eq(t1.size()));
-    for (auto i = 0u; i < r1.size(); ++i) {
-        EXPECT_THAT(r1.top(), Eq(t1.top()));
-        r1.pop();
-        t1.pop();
-    }
-
-}
-
-TEST(FlexibleSyntax, StdStack) {
-    std::stack<std::string> t1;
-    t1.push("first");
-    t1.push("second string");
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-
-}
-
-TEST(FlexibleSyntax, StdUnorderedMap) {
-    std::unordered_map<int, int> t1;
-    t1.emplace(3423,624);
-    t1.emplace(-5484,-845);
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-}
-
-TEST(FlexibleSyntax, StdUnorderedMultiMap) {
-    std::unordered_multimap<std::string, int> t1;
-    t1.emplace("one",624);
-    t1.emplace("two",-845);
-    t1.emplace("one",897);
-
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
-}
-
-TEST(FlexibleSyntax, StdMap) {
-    std::map<int, int> t1;
-    t1.emplace(3423,624);
-    t1.emplace(-5484,-845);
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-}
-
-TEST(FlexibleSyntax, StdMultiMap) {
-    std::multimap<std::string, int> t1;
-    t1.emplace("one",624);
-    t1.emplace("two",-845);
-    t1.emplace("one",897);
-
-    auto res = procArchive(t1);
-    //same key values is not ordered, and operator == compares each element at same position
-    //so we need to compare our selves
-    EXPECT_THAT(res.size(), Eq(3));
-    for (auto it = t1.begin(); it != t1.end();) {
-        const auto lr = t1.equal_range(it->first);
-        const auto rr = res.equal_range(it->first);
-        EXPECT_TRUE(std::distance(lr.first, lr.second) == std::distance(rr.first, rr.second));
-        EXPECT_TRUE(std::is_permutation(lr.first, lr.second, rr.first));
-        it = lr.second;
-    }
-}
-
-TEST(FlexibleSyntax, StdUnorderedSet) {
-    std::unordered_set<std::string> t1;
-    t1.emplace("one");
-    t1.emplace("two");
-    t1.emplace("three");
-
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
-}
-
-TEST(FlexibleSyntax, StdUnorderedMultiSet) {
-    std::unordered_multiset<std::string> t1;
-    t1.emplace("one");
-    t1.emplace("two");
-    t1.emplace("three");
-    t1.emplace("one");
-
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
-}
-
-TEST(FlexibleSyntax, StdSet) {
-    std::set<std::string> t1;
-    t1.emplace("one");
-    t1.emplace("two");
-    t1.emplace("three");
-
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
-}
-
-TEST(FlexibleSyntax, StdMultiSet) {
-    std::multiset<std::string> t1;
-    t1.emplace("one");
-    t1.emplace("two");
-    t1.emplace("three");
-    t1.emplace("one");
-    t1.emplace("two");
-
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
-}
-
-
-TEST(FlexibleSyntax, NestedTypes) {
-    std::unordered_map<std::string, std::vector<std::string>> t1;
-    t1.emplace("my key", std::vector<std::string>{"very", "nice", "string"});
-    t1.emplace("other key", std::vector<std::string>{"just a string"});
-
-    EXPECT_THAT(procArchive(t1), Eq(t1));
-    EXPECT_THAT(procArchiveWithMaxSize(t1), Eq(t1));
-}

tests/serialization_bool.cpp

@@ -26,28 +26,15 @@
 
 using testing::Eq;
 
-using Serializer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
-
-using Deserializer = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
-
 
 TEST(SerializeBooleans, BoolAsBit) {
-
-    SerializationContext ctx{};
+    SerializationContext ctx;
     bool t1{true};
     bool t2{false};
     bool res1;
     bool res2;
-    auto& ser = ctx.createSerializer();
-    ser.enableBitPacking([&t1, &t2](Serializer& sbp) {
-        sbp.boolValue(t1);
-        sbp.boolValue(t2);
-    });
-    auto& des = ctx.createDeserializer();
-    des.enableBitPacking([&res1, &res2](Deserializer& sbp) {
-        sbp.boolValue(res1);
-        sbp.boolValue(res2);
-    });
+    ctx.createSerializer().boolBit(t1).boolBit(t2);
+    ctx.createDeserializer().boolBit(res1).boolBit(res2);
 
     EXPECT_THAT(res1, Eq(t1));
     EXPECT_THAT(res2, Eq(t2));
@@ -60,12 +47,8 @@ TEST(SerializeBooleans, BoolAsByte) {
     bool t2{false};
     bool res1;
     bool res2;
-    auto& ser = ctx.createSerializer();
-    ser.boolValue(t1);
-    ser.boolValue(t2);
-    auto& des = ctx.createDeserializer();
-    des.boolValue(res1);
-    des.boolValue(res2);
+    ctx.createSerializer().boolByte(t1).boolByte(t2);
+    ctx.createDeserializer().boolByte(res1).boolByte(res2);
 
     EXPECT_THAT(res1, Eq(t1));
     EXPECT_THAT(res2, Eq(t2));

tests/serialization_container.cpp

@@ -23,14 +23,10 @@
 
 
 #include <gmock/gmock.h>
-#include <algorithm>
-#include <numeric>
-
 #include "serialization_test_utils.h"
-#include <bitsery/traits/array.h>
-#include <bitsery/traits/list.h>
-#include <bitsery/traits/deque.h>
-#include <bitsery/traits/forward_list.h>
+#include <numeric>
+#include <deque>
+#include <list>
 
 using testing::ContainerEq;
 using testing::Eq;
@@ -40,29 +36,29 @@ using testing::Eq;
  * overload to get container of types
  */
 
-template<typename Container>
+template <typename Container>
 Container getFilledContainer() {
-    return {1, 2, 3, 4, 5, 78, 456, 8, 54};
+    return {1,2,3,4,5,78,456,8,54};
 }
 
-template<>
+template <>
 std::vector<MyStruct1> getFilledContainer<std::vector<MyStruct1>>() {
     return {
-            {0,    1},
-            {2,    3},
-            {4,    5},
-            {6,    7},
-            {8,    9},
-            {11,   34},
-            {5134, 1532}
+            {0,1},
+            {2,3},
+            {4,5},
+            {6,7},
+            {8,9},
+            {11,34},
+            {5134,1532}
     };
 }
 
-template<>
+template <>
 std::list<MyStruct2> getFilledContainer<std::list<MyStruct2>>() {
     return {
-            {MyStruct2::V1, {0,   1}},
-            {MyStruct2::V3, {-45, 45}}
+            {MyStruct2::V1, {0,1}} ,
+            {MyStruct2::V3, {-45,45}}
     };
 }
 
@@ -70,30 +66,28 @@ std::list<MyStruct2> getFilledContainer<std::list<MyStruct2>>() {
  * start testing session
  */
 
-template<typename T>
-class SerializeContainerDynamicSizeArthmeticTypes : public testing::Test {
+template <typename T>
+class SerializeContainerArthmeticTypes:public testing::Test {
 public:
     using TContainer = T;
     using TValue = typename T::value_type;
 
-    const TContainer src = getFilledContainer<TContainer>();
+    const TContainer src= getFilledContainer<TContainer>() ;
     TContainer res{};
 
-    size_t getExpectedBufSize(const SerializationContext &ctx) const {
-        auto size = bitsery::traits::ContainerTraits<TContainer>::size(src);
-        return ctx.containerSizeSerializedBytesCount(size) + size * sizeof(TValue);
+    size_t getExpectedBufSize(const SerializationContext& ctx) const {
+        return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * sizeof(TValue);
     }
 };
 //std::forward_list is not supported, because it doesn't have size() method
 using SequenceContainersWithArthmeticTypes = ::testing::Types<
         std::vector<int>,
         std::list<float>,
-        std::forward_list<int>,
         std::deque<unsigned short>>;
 
-TYPED_TEST_CASE(SerializeContainerDynamicSizeArthmeticTypes, SequenceContainersWithArthmeticTypes);
+TYPED_TEST_CASE(SerializeContainerArthmeticTypes, SequenceContainersWithArthmeticTypes);
 
-TYPED_TEST(SerializeContainerDynamicSizeArthmeticTypes, Values) {
+TYPED_TEST(SerializeContainerArthmeticTypes, Values) {
     SerializationContext ctx{};
     using TValue = typename TestFixture::TValue;
 
@@ -104,51 +98,53 @@ TYPED_TEST(SerializeContainerDynamicSizeArthmeticTypes, Values) {
     EXPECT_THAT(this->res, ContainerEq(this->src));
 }
 
-TYPED_TEST(SerializeContainerDynamicSizeArthmeticTypes, CustomFunctionIncrements) {
+TYPED_TEST(SerializeContainerArthmeticTypes, CustomFunctionIncrements) {
     SerializationContext ctx{};
-    using TValue = typename TestFixture::TValue;
 
-    auto& ser = ctx.createSerializer();
-    ser.container(this->src, 1000, [&ser](TValue& v) {
-        ser.template value<sizeof(v)>(v);
+    auto ser = ctx.createSerializer();
+    ser.container(this->src, 1000, [](auto &s, auto v) {
+        //increment by 1 before writing
+        v++;
+        s.template value<sizeof(v)>(v);
     });
-    auto& des = ctx.createDeserializer();
-    des.container(this->res, 1000, [&des](TValue &v) {
-        des.template value<sizeof(v)>(v);
+    auto des = ctx.createDeserializer();
+    des.container(this->res, 1000, [](auto &s, auto&v ) {
+        s.template value<sizeof(v)>(v);
         //increment by 1 after reading
         v++;
     });
-    //decrement result by 1, before comparing for eq
-    for (auto &v:this->res)
-        v -= 1;
+    //decrement result by 2, before comparing for eq
+    for(auto& v:this->res)
+        v -= 2;
 
     EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
     EXPECT_THAT(this->res, ContainerEq(this->src));
 }
 
 
-template<typename T>
-class SerializeContainerDynamicSizeCompositeTypes : public testing::Test {
+
+
+template <typename T>
+class SerializeContainerCompositeTypes:public testing::Test {
 public:
     using TContainer = T;
     using TValue = typename T::value_type;
 
-    const TContainer src = getFilledContainer<TContainer>();
+    const TContainer src= getFilledContainer<TContainer>();
     TContainer res{};
-
-    size_t getExpectedBufSize(const SerializationContext &ctx) const {
+    size_t getExpectedBufSize(const SerializationContext& ctx) const {
         return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * TValue::SIZE;
     }
 };
 
 
-using SerializeContainerDynamicSizeWithCompositeTypes = ::testing::Types<
+using SequenceContainersWithCompositeTypes = ::testing::Types<
         std::vector<MyStruct1>,
         std::list<MyStruct2>>;
 
-TYPED_TEST_CASE(SerializeContainerDynamicSizeCompositeTypes, SerializeContainerDynamicSizeWithCompositeTypes);
+TYPED_TEST_CASE(SerializeContainerCompositeTypes, SequenceContainersWithCompositeTypes);
 
-TYPED_TEST(SerializeContainerDynamicSizeCompositeTypes, DefaultSerializeFunction) {
+TYPED_TEST(SerializeContainerCompositeTypes, DefaultSerializeFunction) {
     SerializationContext ctx{};
 
     ctx.createSerializer().container(this->src, 1000);
@@ -159,111 +155,15 @@ TYPED_TEST(SerializeContainerDynamicSizeCompositeTypes, DefaultSerializeFunction
 }
 
 
-TYPED_TEST(SerializeContainerDynamicSizeCompositeTypes, CustomFunctionThatDoNothing) {
+TYPED_TEST(SerializeContainerCompositeTypes, CustomFunctionThatDoNothing) {
     SerializationContext ctx{};
-    using TValue = typename TestFixture::TValue;
 
-    auto emptyFnc = [](TValue &) {};
+
+    auto emptyFnc = [](auto& s, auto& v) {};
     ctx.createSerializer().container(this->src, 1000, emptyFnc);
     ctx.createDeserializer().container(this->res, 1000, emptyFnc);
 
     EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(this->src.size())));
 }
 
-template<typename T>
-class SerializeContainerFixedSizeArithmeticTypes : public testing::Test {
-public:
-    using TContainer = T;
 
-    size_t getContainerSize() {
-        T tmp{};
-        return static_cast<size_t>(std::distance(std::begin(tmp), std::end(tmp)));
-    }
-};
-
-using StaticContainersWithIntegralTypes = ::testing::Types<
-        std::array<int16_t, 4>,
-        int16_t[4]>;
-
-TYPED_TEST_CASE(SerializeContainerFixedSizeArithmeticTypes, StaticContainersWithIntegralTypes);
-
-TYPED_TEST(SerializeContainerFixedSizeArithmeticTypes, ArithmeticValues) {
-    using Container = typename TestFixture::TContainer;
-    Container src{5, 9, 15, -459};
-    Container res{};
-
-    SerializationContext ctx;
-    ctx.createSerializer().container<2>(src);
-    ctx.createDeserializer().container<2>(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getContainerSize() * 2));
-    EXPECT_THAT(res, ContainerEq(src));
-
-}
-
-
-template<typename T>
-class SerializeContainerFixedSizeCompositeTypes : public SerializeContainerFixedSizeArithmeticTypes<T> {
-
-};
-
-using StaticContainersWithCompositeTypes = ::testing::Types<
-        std::array<MyStruct1, 4>, MyStruct1[4]>;
-
-TYPED_TEST_CASE(SerializeContainerFixedSizeCompositeTypes, StaticContainersWithCompositeTypes);
-
-TYPED_TEST(SerializeContainerFixedSizeCompositeTypes, DefaultSerializationFunction) {
-    using Container = typename TestFixture::TContainer;
-    Container src{MyStruct1{0, 1}, MyStruct1{8, 9}, MyStruct1{11, 34}, MyStruct1{5134, 1532}};
-    Container res{};
-
-    SerializationContext ctx{};
-    ctx.createSerializer().container(src);
-    ctx.createDeserializer().container(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getContainerSize() * MyStruct1::SIZE));
-    EXPECT_THAT(res, ContainerEq(src));
-}
-
-TYPED_TEST(SerializeContainerFixedSizeCompositeTypes, CustomFunctionThatSerializesAnEmptyByteEveryElement) {
-    using Container = typename TestFixture::TContainer;
-    Container src{MyStruct1{0, 1}, MyStruct1{2, 3}, MyStruct1{4, 5}, MyStruct1{5134, 1532}};
-    Container res{};
-
-    using TValue = decltype(*std::begin(res));
-
-    SerializationContext ctx{};
-    auto& ser = ctx.createSerializer();
-    ser.container(src, [&ser](TValue &v) {
-        char tmp{};
-        ser.object(v);
-        ser.value1b(tmp);
-    });
-    auto& des = ctx.createDeserializer();
-    des.container(res, [&des](TValue &v) {
-        char tmp{};
-        des.object(v);
-        des.value1b(tmp);
-    });
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getContainerSize() * (MyStruct1::SIZE + sizeof(char))));
-    EXPECT_THAT(res, ContainerEq(src));
-}
-
-class SerializeContainer : public ::testing::TestWithParam<size_t> {
-};
-
-TEST_P(SerializeContainer, SizeHasVariableLength) {
-    SerializationContext ctx{};
-    auto emptyFnc = [](uint8_t &) {};
-
-    std::vector<uint8_t > src(GetParam());
-    std::vector<uint8_t > res{};
-    ctx.createSerializer().container(src, std::numeric_limits<size_t>::max(), emptyFnc);
-    ctx.createDeserializer().container(res, std::numeric_limits<size_t>::max(), emptyFnc);
-
-    EXPECT_THAT(res.size(), Eq(src.size()));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(src.size())));
-}
-
-INSTANTIATE_TEST_CASE_P(LargeContainerSize, SerializeContainer, ::testing::Values(0x01, 0x80, 0x4000));

tests/serialization_context.cpp

@@ -1,133 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//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:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//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.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-
-using testing::Eq;
-
-template <typename ... Args>
-struct ConfigWithContext: bitsery::DefaultConfig {
-    using InternalContext = std::tuple<Args...>;
-};
-
-template <typename Context, typename ... Args>
-using SerializerConfigWithContext = bitsery::BasicSerializer<
-        bitsery::AdapterWriter<bitsery::OutputBufferAdapter<Buffer>, ConfigWithContext<Args...>>, Context>;
-
-template <typename Context, typename ... Args>
-using DeserializerConfigWithContext = bitsery::BasicDeserializer<
-        bitsery::AdapterReader<bitsery::InputBufferAdapter<Buffer>, ConfigWithContext<Args...>>, Context>;
-
-template <typename Context>
-using MySerializer = bitsery::BasicSerializer<Writer, Context>;
-
-template <typename Context>
-using MyDeserializer = bitsery::BasicDeserializer<Reader, Context>;
-
-using SingleTypeContext = int;
-using MultipleTypesContext = std::tuple<int, float, char>;
-
-TEST(SerializationContext, WhenUsingContextThenReturnsUnderlyingPointerOrNull) {
-    Buffer buf{};
-    MySerializer<SingleTypeContext> ser1{buf, nullptr};
-    EXPECT_THAT(ser1.context(), ::testing::IsNull());
-
-    MySerializer<MultipleTypesContext> ser2{buf, nullptr};
-    EXPECT_THAT(ser2.context(), ::testing::IsNull());
-
-    SingleTypeContext sctx{};
-    MyDeserializer<SingleTypeContext> des1{InputAdapter{buf.begin(), 1}, &sctx};
-    EXPECT_THAT(des1.context(), Eq(&sctx));
-
-    MultipleTypesContext mctx{};
-    MyDeserializer<MultipleTypesContext> des2{InputAdapter{buf.begin(), 1}, &mctx};
-    EXPECT_THAT(des2.context(), Eq(&mctx));
-
-}
-
-TEST(SerializationContext, WhenContextIsTupleThenContextCastOverloadCastsToIndividualTupleTypes) {
-    Buffer buf{};
-    MySerializer<MultipleTypesContext> ser1{buf, nullptr};
-    EXPECT_THAT(ser1.context<int>(), ::testing::IsNull());
-    EXPECT_THAT(ser1.context<float>(), ::testing::IsNull());
-    EXPECT_THAT(ser1.context<char>(), ::testing::IsNull());
-}
-
-TEST(SerializationContext, WhenContextIsNotTupleThenContextCastOverloadReturnSameType) {
-    Buffer buf{};
-    SingleTypeContext ctx{};
-    MySerializer<SingleTypeContext> ser1{buf, &ctx};
-    EXPECT_THAT(ser1.context<SingleTypeContext>(), Eq(&ctx));
-}
-
-TEST(SerializationContext, SerializerDeserializerCanHaveInternalContextViaConfig) {
-    Buffer buf{};
-    SerializerConfigWithContext<void, float, int> ser{buf};
-    EXPECT_THAT(ser.context<int>(), ::testing::NotNull());
-    EXPECT_THAT(*ser.context<int>(), Eq(0));
-    *ser.context<int>() = 10;
-    EXPECT_THAT(*ser.context<int>(), Eq(10));
-
-    DeserializerConfigWithContext<void, char> des{InputAdapter{buf.begin(), 1}};
-    EXPECT_THAT(des.context<char>(), ::testing::NotNull());
-    EXPECT_THAT(*des.context<char>(), Eq(0));
-    *des.context<char>() = 10;
-    EXPECT_THAT(*des.context<char>(), Eq(10));
-
-    //new instance has new context
-    SerializerConfigWithContext<void, float, int> ser2{buf};
-    EXPECT_THAT(ser2.context<int>(), ::testing::NotNull());
-    EXPECT_THAT(*ser2.context<int>(), Eq(0));
-}
-
-TEST(SerializationContext, WhenInternalAndExternalContextIsTheSamePriorityGoesToInternalContext) {
-    Buffer buf{};
-    int externalCtx = 5;
-
-    SerializerConfigWithContext<int, float, int> ser{buf, &externalCtx};
-    EXPECT_THAT(ser.context<int>(), ::testing::NotNull());
-    EXPECT_THAT(*ser.context<int>(), Eq(0));
-    *ser.context<int>() = 2;
-
-    DeserializerConfigWithContext<int, int, char> des{InputAdapter{buf.begin(), 1}, &externalCtx};
-    EXPECT_THAT(des.context<char>(), ::testing::NotNull());
-    EXPECT_THAT(*des.context<char>(), Eq(0));
-    *des.context<int>() = 3;
-
-    EXPECT_THAT(externalCtx, Eq(5));
-}
-
-TEST(SerializationContext, ContextIfExistsReturnsNullWhenTypeDoesntExists) {
-    Buffer buf{};
-    std::tuple<double, short> extCtx1{};
-
-    SerializerConfigWithContext<std::tuple<double, short>, float, int> ser{buf, &extCtx1};
-    EXPECT_THAT(ser.contextOrNull<int>(), ::testing::NotNull());
-    EXPECT_THAT(ser.contextOrNull<char>(), ::testing::IsNull());
-
-    double extCtx2{};
-    DeserializerConfigWithContext<double, int, char> des{InputAdapter{buf.begin(), 1}, &extCtx2};
-    EXPECT_THAT(des.contextOrNull<double>(), ::testing::NotNull());
-    EXPECT_THAT(des.contextOrNull<float>(), ::testing::IsNull());
-}