version 5.0.1 release

Update memory_resource.h to remove compile warnings

.gitignore

@@ -1,5 +1,6 @@
 .idea/
 .vs/
 build/
-cmake-build-debug/
+cmake-build-*
 CTestConfig.cmake
+Testing/

.travis.yml

@@ -1,18 +1,55 @@
+dist: xenial
 language: cpp
-
-compiler:
-  - gcc
-  # clang
+# CXX_COMPILER and CC_COMPILER is defined, because travis will override CC and CXX environment variables
+# We'll need to override them back "before_install"
+matrix:
+  include:
+    - addons:
+        apt:
+          packages:
+            - g++-5
+      env:
+        - CXXSTD=11
+        - CXX_COMPILER=g++-5
+        - CC_COMPILER=gcc-5
+    - addons:
+        apt:
+          packages:
+            - clang-3.9
+      env:
+        - CXXSTD=11
+        - CXX_COMPILER=clang++-3.9
+        - CC_COMPILER=clang-3.9
+    - addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+      env:
+        - CXXSTD=17
+        - CXX_COMPILER=g++-7
+        - CC_COMPILER=gcc-7
+    - addons:
+        apt:
+          packages:
+            - libstdc++-7-dev
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+            - sourceline: 'deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - CXXSTD=17
+        - CXX_COMPILER=clang++-8
+        - CC_COMPILER=clang-8
 
 before_install:
-  # C++14
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo apt-get update -qq
+  - export CXX=$CXX_COMPILER
+  - export CC=$CC_COMPILER
 
 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
@@ -22,9 +59,12 @@ install:
   - cd ..
 
 before_script:
-  - mkdir build
-  - cd build
-  - cmake -DBITSERY_BUILD_TESTS=ON ..
+  - mkdir build
+  - cd build
+  - cmake -DBITSERY_BUILD_TESTS=ON -DCMAKE_CXX_STANDARD=$CXXSTD ..
 
-script: make && (cd tests && ctest)
 
+script:
+  - make
+  - cd tests
+  - ctest

CHANGELOG.md

@@ -1,3 +1,111 @@
+# [5.0.1](https://github.com/fraillt/bitsery/compare/v5.0.0...v5.0.1) (2019-08-21)
+
+### Bug fixes
+* fixed polymorphic handler deleter in `PolymorphicContext`, now it is captured by value and doesn't depend on lifetime of `PolymorphicContext` instance.
+* fixed compilation errors in `ext/utils/pointer_utils.h` on macOS.
+* reduced warnings on Visual Studio (thanks to [BotellaA](https://github.com/BotellaA))
+
+# [5.0.0](https://github.com/fraillt/bitsery/compare/v4.6.1...v5.0.0) (2019-07-09)
+
+This version reduces library complexity by removing redundant features and changing existing ones.
+Additionally, it provides more customization options for serialization/deserialization flow.
+
+### Features
+
+* added config options to enable/disable checking input adapter and data errors: **CheckAdapterErrors** and **CheckDataErrors**.
+If you can trust your data this will improve deserialization performance. Error checks are enabled by default.
+* all memory allocation in the library can be customized using memory resource (similar to c++ 17 memory resource)
+  * contexts that internally requires to allocate memory are: *PointerLinkingContext, PolymorphicContext, and InheritanceContext*.
+  * extensions, for pointers like types, that allocate memory are: *PointerOwner* and *StdSharedPtr*.
+  More information about pointer extension can be found [here](doc/design/pointers.md).
+
+### Breaking changes
+
+* improved design for serializer/deserializer *context*. It was hard to understand and easy to misuse, so several changes were made.
+  * removed *internal* context from config, because it doesn't actually solve any problems, only allows doing the same thing in multiple ways.
+  * removed `T* context()`. This allowed to get a context that is `std::tuple<...>`, but you can do the same with other methods, by wrapping in an outer tuple, e.g. `std::tuple<std::tuple<...>>`.
+  * if a context is defined, in serializer/deserializer, it is passed (and stored) by reference as a first argument (instead of pointer). Other parameters are forwarded to a input/output adapter.
+  * changed signature `T* context<T>` to `T& context<T>`, this will either return context or doesn't compile, previously it could also return nullptr.
+  * `context<T>` and `contextOrNull<T>` now also check if a type is convertible, so it can work with base classes
+    (e.g. you can require a base class of context in extension, but provided child implementation instead). This allows to further customise extension by providing different context implementations.
+* reworked *BufferedSessions*. It was the only feature that was in a bitsery core and required allocations.
+It was removed and instead was added ability to change read/write position directly for buffered adapters.
+This is also a more flexible solution, and can be used to implement solutions that allow deserialization [in-place](https://github.com/fraillt/bitsery/issues/19) like *flatbuffers* does.
+* changed the signature to all serialization functions that accept lambdas, instead of accepting `(T& )`, now accept `(S& ,T& )`.
+This allows much easier serialization customization, because no additional state is required in a functor, and these methods can now accept function pointers or stateless lambdas.
+* removed various functions/classes that became redundant:
+  * *AdapterWriter/Reader* classes - their functionality is moved to *adapters*.
+  * *AdapterAccess* class - now serializer/deserializer expose adapter directly via `adapter()` method.
+  Additionally adapter can be moved out if serializer/deserializer is rvalue .e.g `auto adapter = std::move(ser).adapter();`.
+  * removed *Writer/Reader* parameters from extensions *serialize/deserialize* methods - because serializer/deserializer now expose *adapter* directly.
+  * *archive* from serializer/deserializer - because `operator()` do the same thing, but it is more terse, and is compatible with `cereal` library.
+  * *align* function from serializer/deserializer - it can now be called directly on input/output adapter.
+  * *UnsafeInputBufferAdapter* - instead config option is provided to disable adapter read errors (*CheckAdapterErrors*).
+  * *isValidState* from stream output adapter - it didn't provide any additional information that couldn't be queried directly on stream object.
+  * *registerBasesList* from *PolymorphicContext* - it was previously deprecated.
+* renamed various classes/functions and files:
+  * *flexible* to **brief_syntax** - this is a big change and might affect a lot of code, but it was necessary, because this name was contradicting to what it actually was trying to achieve.
+  Migration should not be very hard, just global replace `flexible` to `brief_syntax` and it should work:).
+  * *BasicSerializer/BasicDeserializer* to **Serializer/Deserializer** - previously they were aliases, but after removing adapter writer/reader,
+  serializer/deserializer signature has changed to `Serializer/Deserializer<Adapter, Context=void>` and no longer need any alias.
+  * *setError* to **error** for input adapters.
+  * *NetworkEndianness* to **Endianness** in config.
+  * *MeasureSize* adapter moved to separate file `/adapter/measure_size.h`
+
+### Improvements
+
+* added `quickSerialization/Deserialization` overloads that can accept context as first parameter.
+* added convenience classes (functors) **FtorExtValue, FtorExtObject**, in places where you need to provide (des)serialize function/lambda that uses extension.
+e.g. instead of writing `s.container(obj, [](S& s, MyData& data) {s.ext(data, MyExtension{});});` you can write `s.container(obj, FtorExtObject<MyExtension>{});`
+* added more tests for adapters.
+* input adapters now save first error that occured, this allows better diagnostic for what actually happened.
+
+### Bug fixes
+* fixed `enabledBitPacking` in serializer/deserializer where writer/reader and internal context states were not restored properly after bit packing is complete.
+
+# [4.6.1](https://github.com/fraillt/bitsery/compare/v4.6.0...v4.6.1) (2019-06-27)
+
+### Features
+* flexible syntax now also supports `cereal` like serialization interface (thanks to [Luli2020](https://github.com/Luli2020))
+
+### Bug fixes
+* when using `enableBitPacking`, internal context (i.e. context<T>()) in serializer/deserializer was not copied to/from new bitpacking enabled instance.
+
+# [4.6.0](https://github.com/fraillt/bitsery/compare/v4.5.1...v4.6.0) (2019-03-12)
+
+### Features
+* new extensions **StdTuple** and **StdVariant** for `std::tuple` and `std::variant`. These are the first extensions that requires C++17, or higher, standard enabled.
+Although `std::tuple` is C++11 type, but from usage perspective it has exactly the same requirements as `std::variant` and relies heavily on having class template argument deduction guides to make it convenient to use.
+You can easily use `std::tuple` without any extension at all, so the main motivation was to create convenient interface for **StdVariant** and use the same interface for **StdTuple** as well.
+  * instead of providing custom lambda to overload each type in tuple or variant, there was added several helper callable objects.
+  **OverloadValue** wrapper around `s.value<N>(o)`, **OverloadExtValue** wrapper around `s.ext<N>(o, Ext{})` and **OverloadExtObject** wrapper around `s.ext(o, Ext{})`.
+* new extensions **StdDuration** and **StdTimePoint** for `std::chrono::duration` and `std::chrono::time_point`.
+
+### Improvements
+tests now uses `gtest_discover_tests` function, to automatically discover tests, which requires CMake 3.10.
+
+# [4.5.1](https://github.com/fraillt/bitsery/compare/v4.5.0...v4.5.1) (2019-01-16)
+
+### Improvements
+* template specializations, where possible, was changed to avoid using variadics, some Visual Studio compilers has [issues](https://developercommunity.visualstudio.com/content/problem/3437/error-with-c11-variadics.html) with variadic templates.
+* reduced compile warnings for VisualStudio:
+  * added explicit casts
+  * renamed `struct` to `class` where class is used as friend. e.g. `friend class bitsery::Access`, because it is more conventional usage.
+
+# [4.5.0](https://github.com/fraillt/bitsery/compare/v4.4.0...v4.5.0) (2019-01-10)
+
+### Features
+* ability to create non default constructible objects, by defining private default constructor and making `friend class bitsery::Access;` to access it.
+It is not necessary to enforce class invariant immediately, because internal object representation will be overriden anyway.
+
+### Improvements
+* `StdSmartPtr` supports `std::unique_ptr` with custom deleter.
+* `*InputBufferAdapter`(all) can also accept const buffer;
+
+### Bug fixes
+* fixed deserialization in `bitsery/ext/std_map{set}` when target container is not empty.
+* added missing template parameters for specializations on `std` containers in multiple files in `bitsery/ext/*`.
+
 # [4.4.0](https://github.com/fraillt/bitsery/compare/v4.3.0...v4.4.0) (2019-01-08)
 
 ### Features
@@ -224,9 +332,6 @@ Be careful when using deserializing untrusted data and make sure to enforce fund
 * 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.
@@ -234,8 +339,9 @@ Be careful when using deserializing untrusted data and make sure to enforce fund
 * 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*)
 
+### Bug fixes
+* *align* method fixed in *BufferReader*
 
-<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

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.1)
 project(bitsery
         LANGUAGES CXX
-        VERSION 4.4.0)
+        VERSION 5.0.1)
 
 #======== build options ===================================
 option(BITSERY_BUILD_EXAMPLES "Build examples" OFF)

CONTRIBUTING.md

@@ -26,6 +26,16 @@ you contribute:
 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.
 
 
+If you're working with visual studio, there is how to build and run all tests from command line
+```shell
+mkdir build
+cd build
+cmake -DBITSERY_BUILD_TESTS=ON -DGTEST_ROOT="<PATH to GTEST>" -DCMAKE_CXX_FLAGS_RELEASE=/MT ..
+cmake --build . --config Release
+(cd tests && ctest -C Release && cd ..)
+```
+/MT option might be optional, depending on how gtest was built.
+
 ## Style guide
 
-Just use your own judgment and stick to the style of the surrounding code.
+Just use your own judgment and stick to the style of the surrounding code.

README.md

@@ -15,31 +15,33 @@ All cross-platform requirements are enforced at compile time, so serialized data
 * 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.
+* Configurable 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.
   * smart and raw pointers with customizable runtime polymorphism support.
   * fine-grained bit-level serialization control.
 * Easily extendable for any type.
-* Allows flexible or/and verbose syntax for better serialization control.
-* Configurable endianess support.
+* Allows brief or/and verbose syntax for better serialization control.
+* Configurable endianness 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     |
+|                  | data size | serialize | deserialize |
+|------------------|-----------|-----------|-------------|
+| bitsery          | 6913B     | 1252ms    | 1170ms      |
+| bitsery_compress | 4213B     | 1445ms    | 1325ms      |
+| boost            | 11037B    | 9952ms    | 8767ms      |
+| cereal           | 10413B    | 6497ms    | 5470ms      |
+| flatbuffers      | 14924B    | 6762ms    | 2173ms      |
+| yas              | 10463B    | 1352ms    | 1109ms      |
+| yas_compress     | 7315B     | 1673ms    | 1598ms      |
 
-*benchmarked on Ubuntu with GCC 7.1.0, more details can be found [here](https://github.com/fraillt/cpp_serializers_benchmark.git)*
+
+*benchmarked on Ubuntu with GCC 8.3.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.
 
@@ -61,7 +63,7 @@ void serialize(S& s, MyStruct& o) {
     s.value4b(o.i);
     s.value2b(o.e);
     s.container4b(o.fs, 10);
-};
+}
 
 using namespace bitsery;
 
@@ -76,7 +78,6 @@ int main() {
     Buffer buffer;
 
     auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
-
     auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
 
     assert(state.first == ReaderError::NoError && state.second);
@@ -96,6 +97,8 @@ This documentation comprises these parts:
 
 Works with C++11 compiler, no additional dependencies, include `<bitsery/bitsery.h>` and you're done.
 
+> some **bitsery** extensions might require higher C++ standard (e.g. `StdVariant`)
+
 ## Platforms
 
 This library was tested on

doc/README.md

@@ -4,24 +4,24 @@ Once you're familiar with the library consider the following reference material.
 Library design:
 * `fundamental types`
 * `valueNb instead of value`
-* `flexible syntax`
+* `brief syntax`
 * `serializer/deserializer functions overloads`
 * `extending library functionality`
 * `errors handling`
 * `forward/backward compatibility via Growable extension`
-* `pointers`
+* [pointers](design/pointers.md)
 * `inheritance`
 * `polymorphism`
 
 
 Core Serializer/Deserializer functions (alphabetical order):
-* `align` (1.0.0)
+* `operator()` (4.6.1) (when brief syntax is enabled)
+* `adapter` (5.0.0)
 * `boolValue` (4.0.0)
-* `container` (1.0.0)
-* `ext` (2.0.0)
-* `context` (3.0.0)
 * `context<T>` (4.1.0)
 * `contextOrNull<T>` (4.2.0)
+* `enableBitPacking` (4.0.0)
+* `ext` (2.0.0)
 * `object` (1.0.0)
 * `text` (1.0.0)
 * `value` (1.0.0)
@@ -35,36 +35,36 @@ Serializer/Deserializer extensions via `ext` method (alphabetical order):
 * `PointerOwner` (4.1.0)
 * `PointerObserver` (4.1.0)
 * `ReferencedByPointer` (4.1.0)
+* `StdDuration` (4.6.0)
 * `StdMap` (3.0.0)
 * `StdOptional` (2.0.0)
 * `StdQueue` (4.0.0)
 * `StdSet` (4.0.0)
 * `StdSmartPrt` (4.3.0)
 * `StdStack` (4.0.0)
+* `StdTimePoint` (4.6.0)
+* `StdTuple` (4.6.0) (requires c++17)
+* `StdVariant` (4.6.0) (requires c++17)
 * `ValueRange` (3.0.0)
 * `VirtualBaseClass` (4.2.0)
 
-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`
+* `align`
+* `readBits`
+* `readBytes`
+* `readBuffer`
+* `currentReadPos (get/set)` (buffer adapter only)
+* `currentReadEndPos (get/set)` (buffer adapter only)
+* `error (get/set)`
 * `isCompletedSuccessfully`
 
 Output adapters (buffer and stream) functions:
-* `write`
+* `align`
+* `writeBits`
+* `writeBytes`
+* `writeBuffer`
 * `flush`
+* `currentyWritePos (get/set)` (buffer adapter only)
 * `writtenBytesCount` (buffer adapter only)
 
 

doc/design/README.md

@@ -33,18 +33,18 @@ 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!
+Bitsery also applies endianness transformation if necessary.
+* **Brief syntax.** If you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b*, you can use brief syntax.
+Just include <bitsery/brief_syntax.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 across multiple platforms.
+* **Optimized for speed and space.** library itself doesn't do any allocations so data writing/reading is fast as memcpy to/from your buffer.
+It also doesn't serialize any type information, all information needed is written 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.
+* **Configurable 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. BUT, if you trust your data then you can simply disable error checks for better performance.
+* **Supports forward/backward compatibility for your types** library provides access for buffer input/output adapters to directly change read/write position on the buffer.
+*Growable* extension use this capability to allow forward/backward compatibility.
+You can implement your own extensions to do all sorts of other things, like in-place deserialization..
 * **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.
@@ -65,5 +65,7 @@ Bitsery allows to use bit-level operations and has two extensions that use them:
 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*.
+* **Configurable endianness 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 :)
+
+It should also be noted, that extensions that allocate memory (e.g. pointer serialization/deserialization) allow to provide memory resource (similar to C++17 `std::pmr::memory_resource`).

doc/design/pointers.md

@@ -0,0 +1,39 @@
+*document in progress*
+
+## Extensions 
+Raw pointers are managed by three extensions:
+  * **PointerOwner** - manages a lifetime of the pointer, creates or destroys if required.
+  * **PointerObserver** - doesn't own pointer so it doesn't create or destroy anything.
+  * **ReferencedByPointer** - when a non-owning pointer (*PointerObserver*) points to reference type, this extension marks this object as a valid target for PointerObserver.
+
+"Smart" pointers, from c++ standard lib (std), are managed by: 
+ * **StdSmartPtr** - can accept unique_ptr, shared_ptr and weak_ptr
+
+## Implementation details
+ 
+All aforementioned extensions derive from single base class `PointerObjectExtensionBase`.
+This base class accepts three template parameters that customise its behaviour.
+  * `TPtrManager\<T\>` - describes how particular pointer type should be handled: 
+  pointer creation/destruction describes a type of pointer (e.g. owning, shared, observer), and how to actually get value for pointer object. 
+  This is the place to start if you want to implement pointer support for your custom type. \<T\> is type of pointer object, e.g. `std::unique_ptr<MyType>`, `MyType*`
+  * `TPolymorphicContext\<RTTI\>` - provides the functionality to register class hierarchies for your types with serializer, and deserializer, in order to polymorphically serialize/deserialize objects.
+  \<RTTI\> template parameter provides runtime information about a type that is used to construct class hierarchies and save them to read/write them to buffer.   
+  * `RTTI` - this template parameter provides information if a type is polymorphic, and if it is, then it is used in `TPolymorphicContext\<RTTI\>`. 
+  Some pointer managers, like `PointerObserver` and `ReferencedByPointer` never requires polymorphic context. In these cases, you need to provide RTTI that will return `isPolymorphic`=false for all types.
+  By default all pointers extensions use `StandardRTTI` from `/ext/utils/rtti_utils.h` that internally uses `typeid` and `dynamic_cast`.
+  If your environment doesn't allow RTTI, you can provide your own RTTI for your types.
+
+## Allocation and memory resources
+ 
+Allocation is implemented using memory resources (similar to `std::pmr::memory_resource` from c++17),
+and it is called `MemResourceBase` from "ext/utils/memory_allocator.h". The core difference between standard one
+is that it has additional `size_t typeId` field for `allocate` and `deallocate` methods, and this typeId is returned from `RTTI`.
+There are few options to customise pointer allocation for your pointers by using `MemResourceBase`:
+  * invoke `setMemResource` in `PointerLinkingContext`.
+  * pass memory resource to pointer manager constructor, along with boolean parameter that specifies if this memory resource should propagate when deserializing child objects.
+If no memory resource is provided, then `MemResourceNewDelete` is used, which calls `::operator new(bytes)` and `::operator delete(ptr)`.
+
+**IMPORTANT**: there are few things that you should know to correctly use custom allocations with `StdSmartPtr`:
+  * Memory resource must live as long as the last object, that was allocated with it (this is required by std::shared_ptr, custom deleter is provided, that will be able to deallocate correctly when a shared pointer is destroyed).
+  * std::unique_ptr is allocated and deallocated using provided memory resource.
+  If you create unique pointers your self, make sure that it uses the same memory resource, because bitsery will not call `.reset` method on pointer, and instead `.release()` it and deallocate manually.

doc/tutorial/hello_world.md

@@ -2,11 +2,11 @@
 
 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.
+Older versions might work, but they have not been tested.
 
 ## Get bitsery
 
-bitsery can be directly included in your project or installed anywhere you can access header files.
+**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.
 
@@ -27,11 +27,14 @@ 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.
+Include  |  Description
+--|--
+`<bitsery/bitsery.h>`  |  This is a core header, that includes our Serializer and Deserializer.
+`<bitsery/adapter/buffer.h>`  |  In order to write/read data, we need a specific adapter, depending on what underlying buffer will be. In this example, we'll be using `std::vector` as our buffer, so we include the buffer adapter.
+`<bitsery/traits/...>`  |  Traits tell the library how to efficiently serialize a particular container. Many common STL containers are supported out of the box.
+
+Create alias types for *InputAdapter* and *OutputAdapter* using our vector as buffer.
 
 ## Add serialization method for your type
 
@@ -55,7 +58,7 @@ void serialize(S& s, MyStruct& o) {
 
 **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.
+**bitsery** supports two ways how to describe your serialization flow: *verbose syntax* (as in example) or *brief syntax*, similar to *cereal* library, just include `<bitsery/brief_syntax.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.
@@ -73,9 +76,8 @@ 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);
+  auto writtenSize = quickSerialization(OutputAdapter{buffer}, data);
+  auto state = quickDeserialization(InputAdapter{buffer.begin(), writtenSize}, res);
 ```
 
 These helper functions use default configuration *bitsery::DefaultConfig*
@@ -98,30 +100,29 @@ using OutputAdapter = OutputBufferAdapter<Buffer>;
 using InputAdapter = InputBufferAdapter<Buffer>;
 
 struct MyStruct {
-    uint32_t i;
-    char str[6];
-    std::vector<float> fs;
+  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);
+  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{};
+  MyStruct data{8941, "hello", {15.0f, -8.5f, 0.045f}};
+  MyStruct res{};
 
-    Buffer buffer;
-    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
+  Buffer buffer;
+  auto writtenSize = quickSerialization(OutputAdapter{buffer}, data);
+  auto state = quickDeserialization(InputAdapter{buffer.begin(), writtenSize}, res);
 
-    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);
+  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**
+**currently documentation and tutorial is progress, but for more usage examples see examples folder**

examples/CMakeLists.txt

@@ -29,11 +29,6 @@ endif()
 
 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})
     get_filename_component(ExampleName ${ExampleFile} NAME_WE)
     add_executable(bitsery.example.${ExampleName} ${ExampleFile})

examples/bit_packing.cpp

@@ -31,7 +31,7 @@ namespace MyTypes {
         //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) {
+            sbp.container(o.path, 1000, [](typename S::BPEnabledType& 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);

examples/brief_syntax.cpp

@@ -1,12 +1,12 @@
 #include <bitsery/bitsery.h>
 #include <bitsery/adapter/buffer.h>
-//include flexible header, to use flexible syntax
-#include <bitsery/flexible.h>
+//to use brief syntax always include this header
+#include <bitsery/brief_syntax.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/...>
+//instead of including <bitsery/traits/vector.h> for vector traits, now we also need traits to work with brief_syntax types.
+//so include everything from <bitsery/brief_syntax/...> instead of <bitsery/traits/...>
 //otherwise we'll get static assert error, saying to define serialize function.
-#include <bitsery/flexible/vector.h>
+#include <bitsery/brief_syntax/vector.h>
 
 enum class MyEnum:uint16_t { V1,V2,V3 };
 struct MyStruct {
@@ -17,13 +17,12 @@ struct MyStruct {
     //define serialize function as usual
     template <typename S>
     void serialize(S& s) {
-        //now we can use flexible syntax with
-        s.archive(i, e, fs);
+        //now we can use brief syntax with
+        s(i, e, fs);
     }
 
 };
 
-
 using namespace bitsery;
 
 //some helper types

examples/composite_types.cpp

@@ -0,0 +1,115 @@
+#include <bitsery/bitsery.h>
+#include <bitsery/adapter/buffer.h>
+#include <bitsery/traits/vector.h>
+// include extensions to work with tuples and variants
+// these extesions only work with C++17
+
+#if __cplusplus > 201402L
+#include <bitsery/ext/std_tuple.h>
+#include <bitsery/ext/std_variant.h>
+// let's include this extension to make it more interesting :)
+#include <bitsery/ext/compact_value.h>
+
+struct MyStruct {
+    std::vector<int32_t> v{};
+    float f{};
+
+    bool operator==(const MyStruct& rhs) const {
+        return v == rhs.v && f == rhs.f;
+    }
+};
+
+template<typename S>
+void serialize(S& s, MyStruct& o) {
+    s.container4b(o.v, 1000);
+    s.value4b(o.f);
+}
+
+// this will be the type that we want to serialize/deserialize
+using MyTuple = std::tuple<float, MyStruct>;
+using MyVariant = std::variant<int64_t, MyTuple, MyStruct>;
+
+// for convenience
+using namespace bitsery;
+
+// define default serialize function for MyVariant, so that we could use quickSerialization/Deserialization functions
+template<typename S>
+void serialize(S& s, MyVariant& o) {
+    // in order to serialize a variant, it needs to know how to do it for all types
+    // we can do this simply by providing any callable object, that accepts serializer and type as arguments
+    s.ext(o, ext::StdVariant{
+        // specify how to serialize tuple by creating a lambda
+        [](S& s, MyTuple& o) {
+            // StdTuple is used exactly the same as StdVariant
+            s.ext(o, ext::StdTuple{
+                // this is convenient callable object to specify integral value size
+                // it is different equivalent to lambda [](auto& s, float&o) { s.value4b(o);}
+                ext::OverloadValue<float, 4>{},
+                // it is not required to provide MyStruct overload, because it we have defined 'serialize' function for it
+            });
+        },
+        // this might also be useful if you want to overload using extension
+        ext::OverloadExtValue<int64_t, 8, ext::CompactValue>{},
+        // you can even go further and instead of writing lambda for MyTuple you can as well compose the same functionality
+        // with OverloadExtObject, like this:
+        // (comment out MyTuple lambda, and uncomment this)
+        // ext::OverloadExtObject<MyTuple, ext::StdTuple<ext::OverloadValue<float, 4>>>{},
+
+        // we can also override default 'serialize' function by creating an overloading for that type
+        [](S& s, MyStruct& o) {
+            s.value4b(o.f);
+            s.container(o.v, 1000, [](S& s, int32_t& v) {
+                s.ext4b(v, ext::CompactValue{});
+            });
+        },
+        // NOTE.
+        // it is possible to provide "auto" as type parameter
+        // this will allow you to override all default 'serialize' functions
+        // but in this case it will not be called, because we have explicitly provided overloads for all variant types
+        // also note, that first parameter (serializer) is also "auto", this is required, so that it would be least specialized case
+        // otherwise it will not compile if you any ext::Overload* helper defined, because it will have ambiguous definitions
+        // (ext::OverLoad* defines (templated_type& s, concrete_type& o) and lambda would be (concrete_type& s, templated_type& o))
+        [](auto& , auto& ) {
+            assert(false);
+        }
+    });
+}
+
+
+//some helper types
+using Buffer = std::vector<uint8_t>;
+using OutputAdapter = OutputBufferAdapter<Buffer>;
+using InputAdapter = InputBufferAdapter<Buffer>;
+
+int main() {
+
+    //set some random data
+    MyVariant data{MyTuple{-7549, {{-451, 2, 968, 75, 4, 156, 49}, 874.4f}}};
+//    MyVariant data{MyStruct{{-451, 2, 968, 75, 4, 156, 49}, 874.4f}};
+    MyVariant 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);
+
+    //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);
+
+    assert(state.first == ReaderError::NoError && state.second);
+    assert(data == res);
+}
+#else
+#if defined(_MSC_VER)
+#pragma message("example works only on c++17")
+#else
+#warning "example works only on c++17"
+#endif
+int main() {
+    return 0;
+}
+
+#endif

examples/context_usage.cpp

@@ -34,15 +34,15 @@ namespace MyTypes {
     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) {
+        //NOTE: if context is optional then you can call contextOrNull<T>, and it will return null if T doesn't exists
+        auto maxMonsters = s.template context<int>();
+        auto& dmgRange = s.template context<std::pair<uint32_t, uint32_t>>();
+
+        s.container(o.monsters, maxMonsters, [&dmgRange] (S& s, 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};
+            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);
@@ -53,26 +53,24 @@ namespace MyTypes {
 
 }
 
-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:
+//context can contain multiple types by wrapping these types in std::tuple
+//in serialization function we can get type that we need 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>>;
-
 //NOTE:
 // if your context has no additional usage outside of serialization flow,
 // then you can create it internally via configuration (see inheritance.cpp)
+using Context = std::tuple<int, std::pair<uint32_t, uint32_t>>;
+
+//use fixed-size buffer
+using Buffer = std::vector<uint8_t>;
+using namespace bitsery;
+// define adapter types,
+using OutputAdapter = OutputBufferAdapter<Buffer>;
+using InputAdapter = InputBufferAdapter<Buffer>;
 
 int main() {
 
@@ -92,18 +90,10 @@ int main() {
 
     //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();
+    auto writtenSize = quickSerialization(ctx, OutputAdapter{buffer}, data);
 
     MyTypes::GameState res{};
-    BasicDeserializer <AdapterReader<InputAdapter, bitsery::DefaultConfig>, Context> des { InputAdapter{buffer.begin(), writtenSize}, &ctx};
-    des.object(res);
-    auto& r = AdapterAccess::getReader(des);
+    auto state = quickDeserialization(ctx, InputAdapter{buffer.begin(), writtenSize}, res);
 
-    assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
+    assert(state.first == ReaderError::NoError && state.second);
 }

examples/file_stream.cpp

@@ -21,9 +21,6 @@ void serialize(S& s, MyStruct& o) {
 
 using namespace bitsery;
 
-//some helper types
-using Stream = std::fstream;
-
 int main() {
     //set some random data
     MyStruct data{8941, MyEnum::V2, 0.045};
@@ -31,17 +28,17 @@ int main() {
 
     //open file stream for writing and reading
     auto fileName = "test_file.bin";
-    Stream s{fileName, s.binary | s.trunc | s.out};
+    std::fstream 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();
+    ser.adapter().flush();
     s.close();
     //reopen for reading
 

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/forward_backward_compatibility.cpp

@@ -25,7 +25,7 @@ namespace MyTypes {
         template <typename S>
         void serialize (S& s) {
             //forward/backward compatibility for monsters
-            s.ext(*this, bitsery::ext::Growable{}, [&s](Weapon& o1) {
+            s.ext(*this, bitsery::ext::Growable{}, [](S& s, Weapon& o1) {
                 s.text1b(o1.name, 20);
                 s.value2b(o1.damage);
             });
@@ -54,7 +54,7 @@ namespace MyTypes {
     template <typename S>
     void serialize (S& s, Monster& o) {
         //forward/backward compatibility for monsters
-        s.ext(o, bitsery::ext::Growable{}, [&s](Monster& o1) {
+        s.ext(o, bitsery::ext::Growable{}, [](S& s, Monster& o1) {
             s.value1b(o1.color);
             s.value2b(o1.mana);
             s.value2b(o1.hp);
@@ -75,11 +75,6 @@ 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{};
@@ -89,17 +84,11 @@ int main() {
     //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();
-
+    auto writtenSize = quickSerialization<OutputAdapter>(buffer, data);
 
     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());
+    auto state = quickDeserialization<InputAdapter>({buffer.begin(), writtenSize}, res);
+
+    assert(state.first == ReaderError::NoError && state.second);
 }

examples/inheritance.cpp

@@ -1,5 +1,5 @@
 //
-//this example coverls all the corner cases that can happen using inherintace
+//this example covers all the corner cases that can happen using inheritance
 //in reality virtual inherintance is usually avoided, so your code would look much simpler.
 //
 
@@ -12,7 +12,6 @@
 //  BaseClass - normal inheritance
 //  VirtualBaseClass - when virtual inheritance is used
 //in order for virtual inheritance to work, InheritanceContext is required. for normal inheritance it is not required
-//it can be created either internally (via configuration) or externally (pointer to context).
 #include <bitsery/ext/inheritance.h>
 
 using bitsery::ext::BaseClass;
@@ -32,7 +31,7 @@ struct Derive1:virtual Base {// virtually inherits from base
 };
 template <typename S>
 void serialize(S& s, Derive1& o) {
-    //define virtual inheritance, it will not compile if InheritanceContext is not defined in serializer/deserialzer
+    //define virtual inheritance, it will not compile if InheritanceContext is not defined in serializer/deserializer
     s.ext(o, VirtualBaseClass<Base>{});
     s.value1b(o.y1);
 }
@@ -81,18 +80,11 @@ namespace bitsery {
 
 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>;
+using Writer = OutputBufferAdapter<Buffer>;
+using Reader = InputBufferAdapter<Buffer>;
 
 int main() {
 
@@ -103,15 +95,13 @@ int main() {
 
     Buffer buf{};
 
-    BasicSerializer<Writer> ser{OutputBufferAdapter<Buffer>{buf}, nullptr};
-    ser.object(data);
-    auto writtenSize = AdapterAccess::getWriter(ser).writtenBytesCount();
+    ext::InheritanceContext ctx1;
+    auto writtenSize = quickSerialization(ctx1, Writer{buf}, data);
+    assert(writtenSize == 4);//base is serialized once, because it is inherited virtually
 
     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());
-
+    ext::InheritanceContext ctx2;
+    auto state = quickDeserialization(ctx2, Reader{buf.begin(), writtenSize}, res);
+    assert(state.first == ReaderError::NoError && state.second);
     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/non_default_constructible.cpp

@@ -0,0 +1,64 @@
+//
+// example of how to deserialize non default constructible objects
+//
+
+#include <bitsery/bitsery.h>
+#include <bitsery/adapter/buffer.h>
+#include <bitsery/traits/vector.h>
+
+class MyData {
+    //define your private data
+    float _x{0};
+    float _y{0};
+    //make bitsery:Access friend
+    friend class bitsery::Access;
+    //create default constructor, don't worry about class invariant, it will be restored in deserialization
+    MyData() = default;
+    //define serialize function
+
+    template <typename S>
+    void serialize(S& s) {
+        s.value4b(_x);
+        s.value4b(_y);
+    }
+public:
+    //define non default public constructor
+    MyData(float x, float y):_x{x}, _y{y} {}
+    //this is for convenience
+    bool operator ==(const MyData&rhs) const {
+        return _x == rhs._x && _y == rhs._y;
+    }
+};
+
+using namespace bitsery;
+
+//some helper types
+using Buffer = std::vector<uint8_t>;
+using Writer = OutputBufferAdapter<Buffer>;
+using Reader = InputBufferAdapter<Buffer>;
+
+int main() {
+
+    //initialize our data
+    std::vector<MyData> data{};
+    data.emplace_back(145.4f, 84.48f);
+    std::vector<MyData> res{};
+
+    //create buffer
+    Buffer buffer{};
+
+    //we cant use quick (de)serialization helper methods, because we ant to serialize container directly
+    //create writer and serialize container
+    Serializer<Writer> ser{buffer};
+    ser.container(data, 10);
+    ser.adapter().flush();
+
+    //create reader and deserialize container
+    Deserializer<Reader> des{buffer.begin(), ser.adapter().writtenBytesCount()};
+    des.container(res, 10);
+
+    //check if everything went ok
+    assert(des.adapter().error() == ReaderError::NoError && des.adapter().isCompletedSuccessfully());
+    assert(res == data);
+}
+

examples/raw_pointers.cpp

@@ -56,7 +56,7 @@ private:
         s.value4b(i1);
 
         //set container elements to be candidates for non-owning pointers
-        s.container(vdata, 100, [&s](MyStruct& d){
+        s.container(vdata, 100, [](S& s, MyStruct& d){
             s.ext(d, ReferencedByPointer{});
         });
         //contains non owning pointers
@@ -67,7 +67,7 @@ private:
         //
         //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.container(vptr, 100, [](S& s, MyStruct* (&d)){
             s.ext(d, PointerObserver{});
         });
         //observer
@@ -82,17 +82,14 @@ using namespace bitsery;
 
 //some helper types
 using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
+using Writer = OutputBufferAdapter<Buffer>;
+using Reader = 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:
+//if we would require additional 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
@@ -115,16 +112,10 @@ int main() {
     //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
+    //in order to use pointers, we need to pass pointer linking context 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();
+        writtenSize = quickSerialization(ctx, Writer{buffer}, data);
 
         //make sure that pointer linking context is valid
         //this ensures that all non-owning pointers points to data that has been serialized,
@@ -135,13 +126,9 @@ int main() {
     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);
+        auto state = quickDeserialization(ctx, Reader{buffer.begin(), writtenSize}, res);
         //check if everything went find
-        assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
+        assert(state.first == ReaderError::NoError && state.second);
         //also check for dangling pointers, after deserialization
         assert(ctx.isValid());
     }

examples/smart_pointers_with_polymorphism.cpp

@@ -153,7 +153,7 @@ void serialize(S &s, SomeShapes &o) {
     // bitsery will work regardless
     s.ext(o.weakPtr, StdSmartPtr{});
     s.ext(o.refPtr, PointerObserver{});
-    s.container(o.sharedList, 100, [&s](std::shared_ptr<Shape> &item) {
+    s.container(o.sharedList, 100, [](S& s, std::shared_ptr<Shape> &item) {
         s.ext(item, StdSmartPtr{});
     });
 }
@@ -187,8 +187,8 @@ using namespace bitsery;
 
 //some helper types
 using Buffer = std::vector<uint8_t>;
-using OutputAdapter = OutputBufferAdapter<Buffer>;
-using InputAdapter = InputBufferAdapter<Buffer>;
+using Writer = OutputBufferAdapter<Buffer>;
+using Reader = InputBufferAdapter<Buffer>;
 
 //we need to define few things in order to work with polymorphism
 //1) we need pointer linking context to work with pointers
@@ -196,10 +196,8 @@ using InputAdapter = InputBufferAdapter<Buffer>;
 using TContext = std::tuple<ext::PointerLinkingContext, ext::PolymorphicContext<ext::StandardRTTI>>;
 //NOTE:
 // RTTI can be customizable, if you can't use dynamic_cast and typeid, and have 'custom' solution
-
-using MySerializer = BasicSerializer<AdapterWriter<OutputAdapter, DefaultConfig>, TContext>;
-using MyDeserializer = BasicDeserializer<AdapterReader<InputAdapter, DefaultConfig>, TContext>;
-
+using MySerializer = Serializer<Writer, TContext>;
+using MyDeserializer = Deserializer<Reader, TContext>;
 
 //checks if deserialized data is equal
 void assertSameShapes(const SomeShapes &data, const SomeShapes &res) {
@@ -232,18 +230,20 @@ int main() {
     //create buffer to store data
     Buffer buffer{};
     size_t writtenSize{};
+    // we will not use quickSerialization/Deserialization functions to show, that we need to register polymorphic classes, explicitly
     {
+
         //STEP 2
-        //bind serializer with base polymorphic types, it will go through all reachable classes that is defined in first step.
-        //so you dont need to add Rectangle to reach for RoundedRectangle
+        // before start serialization/deserialization,
+        // bind it with base polymorphic types, it will go through all reachable classes that is defined in first step.
+        // NOTE: you dont need to add Rectangle to reach for RoundedRectangle
         TContext ctx{};
         std::get<1>(ctx).registerBasesList<MySerializer>(MyPolymorphicClassesForRegistering{});
-        //serialize our data
-        MySerializer ser{OutputAdapter{buffer}, &ctx};
+        //create writer and serialize
+        MySerializer ser{ctx, buffer};
         ser.object(data);
-        auto &w = AdapterAccess::getWriter(ser);
-        w.flush();
-        writtenSize = w.writtenBytesCount();
+        ser.adapter().flush();
+        writtenSize = ser.adapter().writtenBytesCount();
 
         //make sure that pointer linking context is valid
         //this ensures that all non-owning pointers points to data that has been serialized,
@@ -254,12 +254,10 @@ int main() {
     {
         TContext ctx{};
         std::get<1>(ctx).registerBasesList<MyDeserializer>(MyPolymorphicClassesForRegistering{});
-        //serialize our data
-        MyDeserializer des{InputAdapter{buffer.begin(), writtenSize}, &ctx};
+        //deserialize our data
+        MyDeserializer des{ctx, buffer.begin(), writtenSize};
         des.object(res);
-        auto &r = AdapterAccess::getReader(des);
-        //check if everything went find
-        assert(r.error() == ReaderError::NoError && r.isCompletedSuccessfully());
+        assert(des.adapter().error() == ReaderError::NoError && des.adapter().isCompletedSuccessfully());
         //also check for dangling pointers, after deserialization
         assert(std::get<0>(ctx).isValid());
         // clear shared state from pointer linking context,

include/bitsery/adapter/buffer.h

@@ -28,96 +28,113 @@
 
 namespace bitsery {
 
-    //base class that stores container iterators, and is required for session support (for reading sessions data)
+
     template<typename Buffer>
     class BufferIterators {
+        static constexpr bool isConstBuffer = std::is_const<Buffer>::value;
+        using BuffNonConst = typename std::remove_const<Buffer>::type;
+    public:
+        BufferIterators(const BufferIterators&) = delete;
+        BufferIterators& operator=(const BufferIterators&) = delete;
+        BufferIterators(BufferIterators&&) = default;
+        BufferIterators& operator=(BufferIterators&&) = default;
+        virtual ~BufferIterators() = default;
     protected:
-        using TIterator = typename traits::BufferAdapterTraits<Buffer>::TIterator;
 
+        using TIterator = typename std::conditional<isConstBuffer,
+                typename traits::BufferAdapterTraits<BuffNonConst>::TConstIterator,
+                typename traits::BufferAdapterTraits<BuffNonConst>::TIterator>::type;
+        static_assert(details::IsDefined<TIterator>::value,
+                      "Please define BufferAdapterTraits or include from <bitsery/traits/...>");
         BufferIterators(TIterator begin, TIterator end)
-                : posIt{begin},
+                : beginIt{begin},
+                  posIt{begin},
                   endIt{end} {
         }
 
-        friend details::SessionAccess;
-
+        TIterator beginIt;
         TIterator posIt;
         TIterator endIt;
     };
 
-    template<typename Buffer>
-    class InputBufferAdapter : public BufferIterators<Buffer> {
+    template<typename Buffer, typename Config = DefaultConfig>
+    class InputBufferAdapter: public BufferIterators<Buffer>,
+        public details::InputAdapterBaseCRTP<InputBufferAdapter<Buffer,Config>> {
     public:
-
+        friend details::InputAdapterBaseCRTP<InputBufferAdapter<Buffer,Config>>;
+        using TConfig = Config;
         using TIterator = typename BufferIterators<Buffer>::TIterator;
-        using TValue = typename traits::BufferAdapterTraits<Buffer>::TValue;
+        using TValue = typename traits::BufferAdapterTraits<typename std::remove_const<Buffer>::type>::TValue;
         static_assert(details::IsDefined<TValue>::value,
                       "Please define BufferAdapterTraits or include from <bitsery/traits/...>");
-        static_assert(traits::ContainerTraits<Buffer>::isContiguous,
+        static_assert(traits::ContainerTraits<typename std::remove_const<Buffer>::type>::isContiguous,
                       "BufferAdapter only works with contiguous containers");
 
-        InputBufferAdapter(TIterator begin, TIterator end)
-                : BufferIterators<Buffer>(begin, end) {
+        InputBufferAdapter(TIterator begin, TIterator endIt)
+                : BufferIterators<Buffer>(begin, endIt),
+                    _endReadPos{endIt} {
+
         }
 
         InputBufferAdapter(TIterator begin, size_t size)
-                : BufferIterators<Buffer>(begin, std::next(begin, size)) {
+                : BufferIterators<Buffer>(begin, std::next(begin, size)),
+                  _endReadPos{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);
+        InputBufferAdapter(const InputBufferAdapter&) = delete;
+        InputBufferAdapter& operator=(const InputBufferAdapter&) = delete;
+
+        InputBufferAdapter(InputBufferAdapter&&) = default;
+        InputBufferAdapter& operator = (InputBufferAdapter&&) = default;
+
+        void currentReadPos(size_t pos) {
+            currentReadPosChecked(pos, std::integral_constant<bool, Config::CheckAdapterErrors>{});
+        }
+
+        size_t currentReadPos() const {
+            return static_cast<size_t>(std::distance(this->beginIt, this->posIt));
+        }
+
+        void currentReadEndPos(size_t pos) {
+            // assert that CheckAdapterErrors is enabled, otherwise it will simply will not work even if data and buffer is not corrupted
+            static_assert(Config::CheckAdapterErrors, "Please enable CheckAdapterErrors to use this functionality.");
+            const auto buffSize = static_cast<size_t>(std::distance(this->beginIt, this->endIt));
+            if (buffSize >= pos) {
+                _overflowOnReadEndPos = pos == 0;
+                if (pos == 0)
+                    pos = buffSize;
+                _endReadPos = std::next(this->beginIt, pos);
             } else {
-                this->posIt -= size;
-                //set everything to zeros
-                std::memset(data, 0, size);
-                if (error() == ReaderError::NoError)
-                    setError(ReaderError::DataOverflow);
+                error(ReaderError::DataOverflow);
             }
         }
 
+        size_t currentReadEndPos() const {
+            if (_overflowOnReadEndPos)
+                return 0;
+            return static_cast<size_t>(std::distance(this->beginIt, _endReadPos));
+        }
+
         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;
+            return _err;
         }
 
-        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));
+        void error(ReaderError error) {
+            if (_err == ReaderError::NoError) {
+                _err = error;
+                _endReadPos = this->endIt;
+                this->beginIt = this->endIt;
+                this->posIt = this->endIt;
+            }
         }
 
         bool isCompletedSuccessfully() const {
-            return this->posIt == this->endIt;
-        }
-    };
-
-    template<typename Buffer>
-    class UnsafeInputBufferAdapter : 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");
-
-        UnsafeInputBufferAdapter(TIterator begin, TIterator end) : BufferIterators<Buffer>(begin, end) {
+            return this->posIt == this->endIt && _err == ReaderError::NoError;
         }
 
-        UnsafeInputBufferAdapter(TIterator begin, size_t size)
-                : BufferIterators<Buffer>(begin, std::next(begin, size)) {
-        }
+    private:
 
-        void read(TValue *data, size_t size) {
+        void readChecked(TValue *data, size_t size, std::false_type) {
             //for optimization
             auto tmp = this->posIt;
             this->posIt += size;
@@ -125,26 +142,47 @@ namespace bitsery {
             std::memcpy(data, std::addressof(*tmp), size);
         }
 
-        ReaderError error() const {
-            return err;
+        void readChecked(TValue *data, size_t size, std::true_type) {
+            //for optimization
+            auto tmp = this->posIt;
+            this->posIt += size;
+            if (std::distance(this->posIt, _endReadPos) >= 0) {
+                std::memcpy(data, std::addressof(*tmp), size);
+            } else {
+                this->posIt -= size;
+                //set everything to zeros
+                std::memset(data, 0, size);
+                if (_overflowOnReadEndPos)
+                    error(ReaderError::DataOverflow);
+            }
         }
 
-        void setError(ReaderError error) {
-            err = error;
+        void readInternal(TValue *data, size_t size) {
+            readChecked(data, size, std::integral_constant<bool, Config::CheckAdapterErrors>{});
         }
 
-        bool isCompletedSuccessfully() const {
-            return this->posIt == this->endIt;
+        void currentReadPosChecked(size_t pos, std::true_type) {
+            if (static_cast<size_t>(std::distance(this->beginIt, this->endIt)) >= pos) {
+                this->posIt = std::next(this->beginIt, pos);
+            } else {
+                error(ReaderError::DataOverflow);
+            }
         }
 
-    private:
-        ReaderError err = ReaderError::NoError;
+        void currentReadPosChecked(size_t pos, std::false_type) {
+            this->posIt = std::next(this->beginIt, pos);
+        }
+
+        TIterator _endReadPos;
+        ReaderError _err = ReaderError::NoError;
+        bool _overflowOnReadEndPos = true;
     };
 
-    template<typename Buffer>
-    class OutputBufferAdapter {
+    template<typename Buffer, typename Config = DefaultConfig>
+    class OutputBufferAdapter: public details::OutputAdapterBaseCRTP<OutputBufferAdapter<Buffer,Config>> {
     public:
-
+        friend details::OutputAdapterBaseCRTP<OutputBufferAdapter<Buffer,Config>>;
+        using TConfig = Config;
         using TIterator = typename traits::BufferAdapterTraits<Buffer>::TIterator;
         using TValue = typename traits::BufferAdapterTraits<Buffer>::TValue;
 
@@ -159,8 +197,22 @@ namespace bitsery {
             init(TResizable{});
         }
 
-        void write(const TValue *data, size_t size) {
-            writeInternal(data, size, TResizable{});
+        OutputBufferAdapter(const OutputBufferAdapter&) = delete;
+        OutputBufferAdapter& operator=(const OutputBufferAdapter&) = delete;
+        OutputBufferAdapter(OutputBufferAdapter&&) = default;
+        OutputBufferAdapter& operator = (OutputBufferAdapter&&) = default;
+
+        void currentWritePos(size_t pos) {
+            const auto currPos =static_cast<size_t>(std::distance(std::begin(*_buffer), _outIt));
+            const auto maxPos = currPos > pos ? currPos : pos;
+            if (maxPos > _biggestCurrentPos) {
+                _biggestCurrentPos = maxPos;
+            }
+            setCurrentWritePos(pos, TResizable{});
+        }
+
+        size_t currentWritePos() const {
+            return static_cast<size_t> (std::distance(std::begin(*_buffer), _outIt));
         }
 
         void flush() {
@@ -168,15 +220,21 @@ namespace bitsery {
         }
 
         size_t writtenBytesCount() const {
-            return static_cast<size_t>(std::distance(std::begin(*_buffer), _outIt));
+            const auto pos =static_cast<size_t>(std::distance(std::begin(*_buffer), _outIt));
+            return pos > _biggestCurrentPos ? pos : _biggestCurrentPos;
         }
 
     private:
         using TResizable = std::integral_constant<bool, traits::ContainerTraits<Buffer>::isResizable>;
 
-        Buffer *_buffer;
+        void writeInternal(const TValue *data, size_t size) {
+            writeInternalImpl(data, size, TResizable{});
+        }
+
+        Buffer* _buffer;
         TIterator _outIt{};
         TIterator _end{};
+        size_t _biggestCurrentPos{};
 
         /*
          * resizable buffer
@@ -191,7 +249,7 @@ namespace bitsery {
             _outIt = std::begin(*_buffer);
         }
 
-        void writeInternal(const TValue *data, const size_t size, std::true_type) {
+        void writeInternalImpl(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;
@@ -218,7 +276,17 @@ namespace bitsery {
                 _end = std::end(*_buffer);
                 _outIt = std::next(std::begin(*_buffer), pos);
 
-                writeInternal(data, size, std::true_type{});
+                writeInternalImpl(data, size, std::true_type{});
+            }
+        }
+
+        void setCurrentWritePos(size_t pos, std::true_type) {
+            const auto begin = std::begin(*_buffer);
+            if (static_cast<size_t>(std::distance(begin, std::end(*_buffer))) >= pos) {
+                _outIt = std::next(begin, pos);
+            } else {
+                traits::BufferAdapterTraits<Buffer>::increaseBufferSize(*_buffer);
+                setCurrentWritePos(pos, std::true_type{});
             }
         }
 
@@ -230,13 +298,19 @@ namespace bitsery {
             _end = std::end(*_buffer);
         }
 
-        void writeInternal(const TValue *data, size_t size, std::false_type) {
+        void writeInternalImpl(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);
         }
+
+        void setCurrentWritePos(size_t pos, std::false_type) {
+            const auto begin = std::begin(*_buffer);
+            assert(static_cast<size_t>(std::distance(begin, std::end(*_buffer))) >= pos);
+            _outIt = std::next(begin, pos);
+        }
     };
 
 }

include/bitsery/adapter/measure_size.h

@@ -0,0 +1,95 @@
+//MIT License
+//
+//Copyright (c) 2019 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_MEASURE_SIZE_H
+#define BITSERY_ADAPTER_MEASURE_SIZE_H
+
+namespace bitsery {
+
+
+    template<typename Config>
+    class BasicMeasureSize {
+    public:
+
+        static constexpr bool BitPackingEnabled = true;
+        using TConfig = Config;
+        using TValue = void;
+
+        template<size_t SIZE, typename T>
+        void writeBytes(const T&) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            _currPosBits += details::BitsSize<T>::value;
+        }
+
+        template<size_t SIZE, typename T>
+        void writeBuffer(const T*, size_t count) {
+            static_assert(std::is_integral<T>(), "");
+            static_assert(sizeof(T) == SIZE, "");
+            _currPosBits += details::BitsSize<T>::value * count;
+        }
+
+        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);
+            _currPosBits += bitsCount;
+        }
+
+        void currentWritePos(size_t pos) {
+            align();
+            const auto newPos = pos * 8;
+            if (_currPosBits > newPos)
+                _prevLargestPos = _currPosBits;
+            _currPosBits = newPos;
+        }
+
+        size_t currentWritePos() const {
+            return _currPosBits / 8;
+        }
+
+        void align() {
+            auto _scratch = (_currPosBits % 8);
+            _currPosBits += (8 - _scratch) % 8;
+        }
+
+        void flush() {
+            align();
+        }
+
+        //get size in bytes
+        size_t writtenBytesCount() const {
+            const auto max = _currPosBits > _prevLargestPos ? _currPosBits : _prevLargestPos;
+            return max / 8;
+        }
+
+    private:
+        size_t _prevLargestPos{};
+        size_t _currPosBits{};
+    };
+
+    //helper type for default config
+    using MeasureSize = BasicMeasureSize<DefaultConfig>;
+
+}
+
+#endif //BITSERY_ADAPTER_MEASURE_SIZE_H

include/bitsery/adapter/stream.h

@@ -29,58 +29,101 @@
 
 namespace bitsery {
 
-    template <typename TChar, typename CharTraits>
-    class BasicInputStreamAdapter {
+    template <typename TChar, typename Config, typename CharTraits>
+    class BasicInputStreamAdapter: public details::InputAdapterBaseCRTP<BasicInputStreamAdapter<TChar, Config, CharTraits>> {
     public:
+        friend details::InputAdapterBaseCRTP<BasicInputStreamAdapter<TChar, Config, CharTraits>>;
+        using TConfig = Config;
         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);
-            }
+        BasicInputStreamAdapter(const BasicInputStreamAdapter&) = delete;
+        BasicInputStreamAdapter& operator = (const BasicInputStreamAdapter&) = delete;
 
+        BasicInputStreamAdapter(BasicInputStreamAdapter&&) = default;
+        BasicInputStreamAdapter& operator = (BasicInputStreamAdapter&&) = default;
+
+        void currentReadPos(size_t ) {
+            static_assert(std::is_void<TChar>::value, "setting read position is not supported with StreamAdapter");
+        }
+
+        size_t currentReadPos() const {
+            static_assert(std::is_void<TChar>::value, "setting read position is not supported with StreamAdapter");
+            return {};
+        }
+
+        void currentReadEndPos(size_t ) {
+            static_assert(std::is_void<TChar>::value, "setting read position is not supported with StreamAdapter");
+        }
+
+        size_t currentReadEndPos() const {
+            static_assert(std::is_void<TChar>::value, "setting read position is not supported with StreamAdapter");
+            return {};
         }
 
         ReaderError error() const {
-            if (_ios->good())
-                return ReaderError::NoError;
-            return _ios->eof()
-                   ? ReaderError::DataOverflow
-                   : ReaderError::ReadingError;
+            return _err;
         }
+
         bool isCompletedSuccessfully() const {
             if (error() == ReaderError::NoError) {
                 return _ios->rdbuf()->sgetc() == CharTraits::eof();
             }
             return false;
         }
-        void setError(ReaderError ) {
-            //has no effect when using
+
+        void error(ReaderError error) {
+            if (_err == ReaderError::NoError) {
+                _err = error;
+                _zeroIfNoErrors = std::numeric_limits<size_t>::max();
+            }
         }
 
     private:
+
+        void readInternal(TValue* data, size_t size) {
+            readChecked(data, size, std::integral_constant<bool, Config::CheckAdapterErrors>{});
+        }
+
+        void readChecked(TValue* data, size_t size, std::true_type) {
+            if (size - static_cast<size_t>(_ios->rdbuf()->sgetn(data, size)) != _zeroIfNoErrors) {
+                *data = {};
+                if (_zeroIfNoErrors == 0) {
+                    error(_ios->rdstate() == std::ios_base::badbit
+                          ? ReaderError::ReadingError
+                          : ReaderError::DataOverflow);
+                }
+            }
+        }
+
+        void readChecked(TValue* data, size_t size, std::false_type) {
+            _ios->rdbuf()->sgetn(data , size);
+        }
+
         std::basic_ios<TChar, CharTraits>* _ios;
+        size_t _zeroIfNoErrors{};
+        ReaderError _err = ReaderError::NoError;
     };
 
-    template <typename TChar, typename CharTraits>
-    class BasicOutputStreamAdapter {
+    template <typename TChar, typename Config, typename CharTraits>
+    class BasicOutputStreamAdapter: public details::OutputAdapterBaseCRTP<BasicOutputStreamAdapter<TChar, Config, CharTraits>> {
     public:
+        friend details::OutputAdapterBaseCRTP<BasicOutputStreamAdapter<TChar, Config, CharTraits>>;
+        using TConfig = Config;
         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 currentWritePos(size_t ) {
+            static_assert(std::is_void<TChar>::value, "setting write position is not supported with StreamAdapter");
+        }
+
+        size_t currentWritePos() const {
+            static_assert(std::is_void<TChar>::value, "setting write position is not supported with StreamAdapter");
+            return {};
         }
 
         void flush() {
@@ -94,40 +137,43 @@ namespace bitsery {
             return 0u;
         }
 
-        //this method is only for stream writing
-        bool isValidState() const {
-            return !_ios->bad();
+    private:
+
+        void writeInternal(const TValue* data, size_t size) {
+            //for optimization
+            _ios->rdbuf()->sputn( data , size );
         }
 
-    private:
         std::basic_ios<TChar, CharTraits>* _ios;
     };
 
-    template <typename TChar, typename CharTraits, typename TBuffer = std::array<TChar, 256>>
-    class BasicBufferedOutputStreamAdapter {
+    template <typename TChar, typename Config, typename CharTraits, typename TBuffer = std::array<TChar, 256>>
+    class BasicBufferedOutputStreamAdapter:
+        public details::OutputAdapterBaseCRTP<BasicBufferedOutputStreamAdapter<TChar, Config, CharTraits, TBuffer>> {
     public:
+        friend details::OutputAdapterBaseCRTP<BasicBufferedOutputStreamAdapter<TChar, Config, CharTraits, TBuffer>>;
+        using TConfig = Config;
         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),
+                :_ios(std::addressof(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
+        //we need to explicitly declare move logic, because after move buffer might be invalidated
         BasicBufferedOutputStreamAdapter(const BasicBufferedOutputStreamAdapter&) = delete;
         BasicBufferedOutputStreamAdapter& operator = (const BasicBufferedOutputStreamAdapter&) = delete;
 
         BasicBufferedOutputStreamAdapter(BasicBufferedOutputStreamAdapter&& rhs)
-                : _adapter{std::move(rhs._adapter)},
+                : _ios{rhs._ios},
                   _buf{},
                   _outIt{}
         {
@@ -137,7 +183,7 @@ namespace bitsery {
         };
 
         BasicBufferedOutputStreamAdapter& operator = (BasicBufferedOutputStreamAdapter&& rhs) {
-            _adapter = std::move(rhs._adapter);
+            _ios = rhs._ios;
             //get current written size, before move
             auto size = std::distance(std::begin(rhs._buf), rhs._outIt);
             _buf = std::move(rhs._buf);
@@ -145,9 +191,33 @@ namespace bitsery {
             return *this;
         };
 
-        ~BasicBufferedOutputStreamAdapter() = default;
+        void currentWritePos(size_t ) {
+            static_assert(std::is_void<TChar>::value, "setting write position is not supported with StreamAdapter");
+        }
 
-        void write(const TValue* data, size_t size) {
+        size_t currentWritePos() const {
+            static_assert(std::is_void<TChar>::value, "setting write position is not supported with StreamAdapter");
+            return {};
+        }
+
+        void flush() {
+            auto begin = std::begin(_buf);
+            writeToStream(std::addressof(*begin), static_cast<size_t>(std::distance(begin, _outIt)));
+            _outIt = begin;
+            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;
+        }
+
+    private:
+        using TResizable = std::integral_constant<bool, traits::ContainerTraits<TBuffer>::isResizable>;
+
+        void writeInternal(const TValue* data, size_t size) {
             auto tmp = _outIt;
 
 #if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
@@ -155,38 +225,25 @@ namespace bitsery {
             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 {
+            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);
+                writeToStream(std::addressof(*_outIt), static_cast<size_t>(std::distance(_outIt, tmp)));
+                writeToStream(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();
+        void writeToStream(const TValue* data, size_t size) {
+            _ios->rdbuf()->sputn( data , size );
         }
 
-        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);
@@ -195,31 +252,30 @@ namespace bitsery {
             _outIt = std::begin(_buf);
         }
 
-        BasicOutputStreamAdapter<TChar, CharTraits> _adapter;
+        std::basic_ios<TChar, CharTraits>* _ios;
         TBuffer _buf;
         BufferIt _outIt;
     };
 
-    template <typename TChar, typename CharTraits>
-    class BasicIOStreamAdapter:public BasicInputStreamAdapter<TChar, CharTraits>, public BasicOutputStreamAdapter<TChar, CharTraits> {
+    template <typename TChar, typename Config, typename CharTraits>
+    class BasicIOStreamAdapter:public BasicInputStreamAdapter<TChar, Config, CharTraits>, public BasicOutputStreamAdapter<TChar, Config, 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} {
+                :BasicInputStreamAdapter<TChar, Config, CharTraits>{iostream},
+                 BasicOutputStreamAdapter<TChar, Config, 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 OutputStreamAdapter = BasicOutputStreamAdapter<char, DefaultConfig, std::char_traits<char>>;
+    using InputStreamAdapter = BasicInputStreamAdapter<char, DefaultConfig, std::char_traits<char>>;
+    using IOStreamAdapter = BasicIOStreamAdapter<char, DefaultConfig, std::char_traits<char>>;
 
-    using OutputBufferedStreamAdapter = BasicBufferedOutputStreamAdapter<char, std::char_traits<char>>;
+    using OutputBufferedStreamAdapter = BasicBufferedOutputStreamAdapter<char, DefaultConfig, std::char_traits<char>>;
 }
 
 #endif //BITSERY_ADAPTER_STREAM_H

include/bitsery/adapter_reader.h

@@ -1,263 +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();
-            }
-        }
-
-    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,335 +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);
-        }
-
-    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,9 +24,9 @@
 #ifndef BITSERY_BITSERY_H
 #define BITSERY_BITSERY_H
 
-#define BITSERY_MAJOR_VERSION 4
-#define BITSERY_MINOR_VERSION 4
-#define BITSERY_PATCH_VERSION 0
+#define BITSERY_MAJOR_VERSION 5
+#define BITSERY_MINOR_VERSION 0
+#define BITSERY_PATCH_VERSION 1
 
 #define BITSERY_QUOTE_MACRO(name) #name
 #define BITSERY_BUILD_VERSION_STR(major,minor, patch) \

include/bitsery/brief_syntax.h

@@ -21,62 +21,46 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_H
-#define BITSERY_FLEXIBLE_H
+#ifndef BITSERY_BRIEF_SYNTAX_H
+#define BITSERY_BRIEF_SYNTAX_H
 
 #include "details/serialization_common.h"
-#include "details/flexible_common.h"
+#include "bitsery/details/brief_syntax_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
+    //define function that enables s(....) usage
     template<typename S, typename T>
-    void archiveProcess(S &s, T &&head) {
-        flexible::archiveProcessImpl(s, std::forward<T>(head), std::is_reference<T>{});
+    void processBriefSyntax(S& s, T&& head) {
+        static_assert(std::is_lvalue_reference<T>::value || std::is_base_of<brief_syntax::ModFnc, T>::value,
+                      "Argument must be either lvalue or subclass of brief_syntax::ModFnc");
+        s.object(head);
     }
 
     //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]) {
+    brief_syntax::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]) {
+    brief_syntax::CArray<T, N, false> asContainer(T (& obj)[N]) {
         return {obj};
     }
 
-    template <typename T>
-    flexible::MaxSize<T> maxSize(T& obj, size_t max) {
+    template<typename T>
+    brief_syntax::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) {
+    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) {
+    void serialize(S& s, T& v) {
         s.template value<sizeof(T)>(v);
     }
 
@@ -84,18 +68,18 @@ namespace bitsery {
 
     //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]) {
+    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);
+    void serialize(S& s, T (& obj)[N]) {
+        brief_syntax::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>
+    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, "");
@@ -107,4 +91,4 @@ namespace bitsery {
 
 }
 
-#endif //BITSERY_FLEXIBLE_H
+#endif //BITSERY_BRIEF_SYNTAX_H

include/bitsery/brief_syntax/array.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H
-#define BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_ARRAY_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_ARRAY_H
 
 #include "../traits/array.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_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);
+        brief_syntax::processContainer(s, obj);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_ARRAY_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_ARRAY_H

include/bitsery/brief_syntax/chrono.h

@@ -0,0 +1,40 @@
+//MIT License
+//
+//Copyright (c) 2019 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_BRIEF_SYNTAX_TYPE_STD_CHRONO_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_CHRONO_H
+
+#include "../ext/std_chrono.h"
+
+namespace bitsery {
+    template<typename S, typename T, typename P>
+    void serialize(S &s, std::chrono::duration<T, P> &obj) {
+        s.template ext<sizeof(T)>(obj, ext::StdDuration{});
+    }
+
+    template<typename S, typename C, typename T, typename P>
+    void serialize(S &s, std::chrono::time_point<C, std::chrono::duration<T, P>> &obj) {
+        s.template ext<sizeof(T)>(obj, ext::StdTimePoint{});
+    }
+}
+
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_CHRONO_H

include/bitsery/brief_syntax/deque.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H
-#define BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_DEQUE_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_DEQUE_H
 
 #include "../traits/deque.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_common.h"
 
 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::deque<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::deque<T, Allocator> &obj) {
+        brief_syntax::processContainer(s, obj);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_DEQUE_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_DEQUE_H

include/bitsery/brief_syntax/forward_list.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H
-#define BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_FORWARD_LIST_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_FORWARD_LIST_H
 
 #include "../traits/forward_list.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_common.h"
 
 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::forward_list<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::forward_list<T, Allocator> &obj) {
+        brief_syntax::processContainer(s, obj);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_FORWARD_LIST_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_FORWARD_LIST_H

include/bitsery/brief_syntax/list.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_LIST_H
-#define BITSERY_FLEXIBLE_TYPE_STD_LIST_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_LIST_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_LIST_H
 
 #include "../traits/list.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_common.h"
 
 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::list<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::list<T, Allocator> &obj) {
+        brief_syntax::processContainer(s, obj);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_LIST_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_LIST_H

include/bitsery/brief_syntax/map.h

@@ -21,34 +21,30 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_MAP_H
-#define BITSERY_FLEXIBLE_TYPE_STD_MAP_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_MAP_H
+#define BITSERY_BRIEF_SYNTAX_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;
+    template<typename S, typename Key, typename T, typename Compare, typename Allocator>
+    void serialize(S &s, std::map<Key, T, Compare, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
+              [](S& s, Key& key, T& 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;
+    template<typename S, typename Key, typename T, typename Compare, typename Allocator>
+    void serialize(S &s, std::multimap<Key, T, Compare, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
+              [](S& s, Key& key, T& value) {
                   s.object(key);
                   s.object(value);
               });
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_MAP_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_MAP_H

include/bitsery/brief_syntax/memory.h

@@ -20,8 +20,8 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_MEMORY_H
-#define BITSERY_FLEXIBLE_TYPE_STD_MEMORY_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_MEMORY_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_MEMORY_H
 
 #include "../ext/std_smart_ptr.h"
 
@@ -42,4 +42,4 @@ namespace bitsery {
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_MEMORY_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_MEMORY_H

include/bitsery/brief_syntax/queue.h

@@ -21,8 +21,8 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H
-#define BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_QUEUE_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_QUEUE_H
 
 #include "../ext/std_queue.h"
 
@@ -39,4 +39,4 @@ namespace bitsery {
 
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_QUEUE_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_QUEUE_H

include/bitsery/brief_syntax/set.h

@@ -21,23 +21,23 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H
-#define BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_SET_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_SET_H
 
-#include <unordered_set>
+#include <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()) {
+    template<typename S, typename Key, typename Compare, typename Allocator>
+    void serialize(S &s, std::set<Key, Compare, Allocator> &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()) {
+    template<typename S, typename Key, typename Compare, typename Allocator>
+    void serialize(S &s, std::multiset<Key, Compare, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdSet{maxSize});
     }
 
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_SET_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_SET_H

include/bitsery/brief_syntax/stack.h

@@ -21,8 +21,8 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_STACK_H
-#define BITSERY_FLEXIBLE_TYPE_STD_STACK_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_STACK_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_STACK_H
 
 #include "../ext/std_stack.h"
 
@@ -33,4 +33,4 @@ namespace bitsery {
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_STACK_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_STACK_H

include/bitsery/brief_syntax/string.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_STRING_H
-#define BITSERY_FLEXIBLE_TYPE_STD_STRING_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_STRING_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_STRING_H
 
 #include "../traits/string.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_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);
+    template<typename S, typename CharT, typename Traits, typename Allocator>
+    void serialize(S &s, std::basic_string<CharT, Traits, Allocator> &str) {
+        brief_syntax::processContainer(s, str);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_STRING_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_STRING_H

include/bitsery/brief_syntax/tuple.h

@@ -0,0 +1,35 @@
+//MIT License
+//
+//Copyright (c) 2019 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_BRIEF_SYNTAX_TYPE_STD_TUPLE_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_TUPLE_H
+
+#include "../ext/std_tuple.h"
+
+namespace bitsery {
+    template<typename S, typename ...Ts>
+    void serialize(S &s, std::tuple<Ts...> &obj) {
+        s.ext(obj, ext::StdTuple{});
+    }
+}
+
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_TUPLE_H

include/bitsery/brief_syntax/unordered_map.h

@@ -21,30 +21,26 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H
-#define BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_UNORDERED_MAP_H
+#define BITSERY_BRIEF_SYNTAX_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;
+    template<typename S, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
+    void serialize(S &s, std::unordered_map<Key, T, Hash, KeyEqual, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
+              [](S& s, Key& key, T& 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;
+    template<typename S, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
+    void serialize(S &s, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdMap{maxSize},
-              [&s](TKey& key, TValue& value) {
+              [](S& s, Key& key, T& value) {
                   s.object(key);
                   s.object(value);
               });
@@ -52,4 +48,4 @@ namespace bitsery {
 
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_UNORDERED_MAP_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_UNORDERED_MAP_H

include/bitsery/brief_syntax/unordered_set.h

@@ -21,23 +21,23 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_SET_H
-#define BITSERY_FLEXIBLE_TYPE_STD_SET_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_UNORDERED_SET_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_UNORDERED_SET_H
 
-#include <set>
+#include <unordered_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()) {
+    template<typename S, typename Key, typename Hash, typename KeyEqual, typename Allocator>
+    void serialize(S &s, std::unordered_set<Key, Hash, KeyEqual, Allocator> &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()) {
+    template<typename S, typename Key, typename Hash, typename KeyEqual, typename Allocator>
+    void serialize(S &s, std::unordered_multiset<Key, Hash, KeyEqual, Allocator> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
         s.ext(obj, ext::StdSet{maxSize});
     }
 
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_SET_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_UNORDERED_SET_H

include/bitsery/brief_syntax/variant.h

@@ -0,0 +1,35 @@
+//MIT License
+//
+//Copyright (c) 2019 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_BRIEF_SYNTAX_TYPE_STD_VARIANT_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_VARIANT_H
+
+#include "../ext/std_variant.h"
+
+namespace bitsery {
+    template<typename S, typename ...Ts>
+    void serialize(S &s, std::variant<Ts...> &obj) {
+        s.ext(obj, ext::StdVariant{});
+    }
+}
+
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_VARIANT_H

include/bitsery/brief_syntax/vector.h

@@ -21,17 +21,17 @@
 //SOFTWARE.
 
 
-#ifndef BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H
-#define BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H
+#ifndef BITSERY_BRIEF_SYNTAX_TYPE_STD_VECTOR_H
+#define BITSERY_BRIEF_SYNTAX_TYPE_STD_VECTOR_H
 
 #include "../traits/vector.h"
-#include "../details/flexible_common.h"
+#include "bitsery/details/brief_syntax_common.h"
 
 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::vector<TArgs... > &obj) {
-        flexible::processContainer(s, obj);
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::vector<T, Allocator> &obj) {
+        brief_syntax::processContainer(s, obj);
     }
 }
 
-#endif //BITSERY_FLEXIBLE_TYPE_STD_VECTOR_H
+#endif //BITSERY_BRIEF_SYNTAX_TYPE_STD_VECTOR_H

include/bitsery/common.h

@@ -29,24 +29,22 @@
 namespace bitsery {
 
 /*
- * endianess
+ * endianness
  */
     enum class EndiannessType {
         LittleEndian,
         BigEndian
     };
 
-    //default configuration for buffer writing/reading operations
+    // default configuration for serialization and deserialization
     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<>;
+        // defines endianness of data that is read from input adapter and written to output adapter.
+        static constexpr EndiannessType Endianness = EndiannessType::LittleEndian;
+        // these flags allow to improve deserialization performance if data is trusted
+        // enables/disables checks for buffer end or stream read errors in input adapter
+        static constexpr bool CheckAdapterErrors = true;
+        // enables/disables checks for other errors that can significantly affect performance
+        static constexpr bool CheckDataErrors = true;
     };
 
 }

include/bitsery/deserializer.h

@@ -25,57 +25,152 @@
 #define BITSERY_DESERIALIZER_H
 
 #include "details/serialization_common.h"
-#include "adapter_reader.h"
+#include "details/adapter_common.h"
 #include <utility>
 
 namespace bitsery {
 
+    namespace details {
+        template<typename TAdapter>
+        class InputAdapterBitPackingWrapper {
+        public:
 
-    template<typename TAdapterReader, typename TContext = void>
-    class BasicDeserializer {
+            static constexpr bool BitPackingEnabled = true;
+            using TConfig = typename TAdapter::TConfig;
+            using TValue = typename TAdapter::TValue;
+
+            InputAdapterBitPackingWrapper(TAdapter& adapter)
+                : _wrapped{adapter}
+            {
+            }
+
+
+            ~InputAdapterBitPackingWrapper() {
+                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)
+                    this->_wrapped.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) {
+                    this->_wrapped.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);
+                    handleAlignErrors(tmp, std::integral_constant<bool, TConfig::CheckDataErrors>{});
+                }
+            }
+
+            void currentReadPos(size_t pos) {
+                align();
+                this->_wrapped.currentReadPos(pos);
+            }
+
+            size_t currentReadPos() const {
+                return this->_wrapped.currentReadPos();
+            }
+
+            void currentReadEndPos(size_t pos) {
+                this->_wrapped.currentReadEndPos(pos);
+            }
+
+            size_t currentReadEndPos() const {
+                return this->_wrapped.currentReadEndPos();
+            }
+
+            bool isCompletedSuccessfully() const {
+                return this->_wrapped.isCompletedSuccessfully();
+            }
+
+            ReaderError error() const {
+                return this->_wrapped.error();
+            }
+
+            void error(ReaderError error) {
+                this->_wrapped.error(error);
+            }
+
+        private:
+            TAdapter& _wrapped;
+            using UnsignedValue = typename std::make_unsigned<typename TAdapter::TValue>::type;
+            using ScratchType = typename details::ScratchType<UnsignedValue>::type;
+
+            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;
+                        this->_wrapped.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;
+            }
+
+            void handleAlignErrors(ScratchType value, std::true_type) {
+                if (value)
+                    error(ReaderError::InvalidData);
+            }
+
+            void handleAlignErrors(ScratchType, std::false_type) {
+            }
+
+        };
+
+    }
+
+    template<typename TInputAdapter, typename TContext = void>
+    class Deserializer: public details::AdapterAndContextRef<TInputAdapter, TContext> {
     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>;
+        //helper type, that always returns bit-packing enabled type, useful inside deserialize function when enabling bitpacking
+        using BPEnabledType = Deserializer<typename std::conditional<TInputAdapter::BitPackingEnabled,
+            TInputAdapter,
+            details::InputAdapterBitPackingWrapper<TInputAdapter>>::type, TContext>;
+        using TConfig = typename TInputAdapter::TConfig;
 
-        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;
-        }
-
-        template <typename T>
-        T* context(){
-            return details::getContext<T>(_context, _internalContext);
-        }
-
-        template <typename T>
-        T* contextOrNull(){
-            return details::getContextIfTypeExists<T>(_context, _internalContext);
-        }
+        using details::AdapterAndContextRef<TInputAdapter, TContext>::AdapterAndContextRef;
 
         /*
          * object function
@@ -83,33 +178,33 @@ namespace bitsery {
 
         template<typename T>
         void object(T &&obj) {
-            details::SerializeFunction<BasicDeserializer, T>::invoke(*this, std::forward<T>(obj));
+            details::SerializeFunction<Deserializer, T>::invoke(*this, std::forward<T>(obj));
         }
 
         template<typename T, typename Fnc>
         void object(T &&obj, Fnc &&fnc) {
-            fnc(std::forward<T>(obj));
+            fnc(*this, 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)...);
+
+        template <typename... TArgs>
+        Deserializer &operator()(TArgs &&... args) {
+            archive(std::forward<TArgs>(args)...);
+            return *this;
         }
 
         /*
          * value
          */
 
-        template<size_t VSIZE, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
+        template<size_t VSIZE, typename T>
         void value(T &v) {
+            static_assert(details::IsFundamentalType<T>::value, "Value must be integral, float or enum type.");
             using TValue = typename details::IntegralFromFundamental<T>::TValue;
-            _reader.template readBytes<VSIZE>(reinterpret_cast<TValue &>(v));
+            this->_adapter.template readBytes<VSIZE>(reinterpret_cast<TValue &>(v));
         }
 
         /*
@@ -117,7 +212,7 @@ namespace bitsery {
          */
         template <typename Fnc>
         void enableBitPacking(Fnc&& fnc) {
-            procEnableBitPacking(std::forward<Fnc>(fnc), std::integral_constant<bool, TAdapterReader::BitPackingEnabled>{});
+            procEnableBitPacking(std::forward<Fnc>(fnc), std::integral_constant<bool, TInputAdapter::BitPackingEnabled>{});
         }
 
         /*
@@ -129,7 +224,7 @@ namespace bitsery {
             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));
+            extension.deserialize(*this, obj, std::forward<Fnc>(fnc));
         }
 
         template<size_t VSIZE, typename T, typename Ext>
@@ -139,7 +234,7 @@ namespace bitsery {
                           "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);});
+            extension.deserialize(*this, obj, [](Deserializer& s, VType &v) { s.value<VSIZE>(v);});
         }
 
         template<typename T, typename Ext>
@@ -149,14 +244,16 @@ namespace bitsery {
                           "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); });
+            extension.deserialize(*this, obj, [](Deserializer& s, VType &v) { s.object(v); });
         }
 
         /*
          * boolValue
          */
         void boolValue(bool &v) {
-            procBoolValue(v, std::integral_constant<bool, TAdapterReader::BitPackingEnabled>{});
+            procBoolValue(v,
+                std::integral_constant<bool, TInputAdapter::BitPackingEnabled>{},
+                std::integral_constant<bool, TInputAdapter::TConfig::CheckDataErrors>{});
         }
 
         /*
@@ -170,7 +267,7 @@ namespace bitsery {
             static_assert(traits::ContainerTraits<T>::isResizable,
                           "use text(T&) overload without `maxSize` for static containers");
             size_t length;
-            details::readSize(_reader, length, maxSize);
+            readSize(length, maxSize);
             traits::ContainerTraits<T>::resize(str, length + (traits::TextTraits<T>::addNUL ? 1u : 0u));
             procText<VSIZE>(str, length);
         }
@@ -182,7 +279,7 @@ namespace bitsery {
             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));
+            readSize(length, traits::ContainerTraits<T>::size(str));
             procText<VSIZE>(str, length);
         }
 
@@ -199,7 +296,7 @@ namespace bitsery {
             static_assert(traits::ContainerTraits<T>::isResizable,
                           "use container(T&) overload without `maxSize` for static containers");
             size_t size{};
-            details::readSize(_reader, size, maxSize);
+            readSize(size, maxSize);
             traits::ContainerTraits<T>::resize(obj, size);
             procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
         }
@@ -211,7 +308,7 @@ namespace bitsery {
             static_assert(traits::ContainerTraits<T>::isResizable,
                           "use container(T&) overload without `maxSize` for static containers");
             size_t size{};
-            details::readSize(_reader, size, maxSize);
+            readSize(size, maxSize);
             traits::ContainerTraits<T>::resize(obj, size);
             procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
         }
@@ -223,7 +320,7 @@ namespace bitsery {
             static_assert(traits::ContainerTraits<T>::isResizable,
                           "use container(T&) overload without `maxSize` for static containers");
             size_t size{};
-            details::readSize(_reader, size, maxSize);
+            readSize(size, maxSize);
             traits::ContainerTraits<T>::resize(obj, size);
             procContainer(std::begin(obj), std::end(obj));
         }
@@ -257,10 +354,6 @@ namespace bitsery {
             procContainer(std::begin(obj), std::end(obj));
         }
 
-        void align() {
-            _reader.align();
-        }
-
         //overloads for functions with explicit type size
 
         template<typename T>
@@ -330,12 +423,11 @@ namespace bitsery {
         void container8b(T &&obj) { container<8>(std::forward<T>(obj)); }
 
     private:
-        friend AdapterAccess;
-
-        TAdapterReader _reader;
-        TContext* _context;
-        typename TReader::TConfig::InternalContext _internalContext;
 
+        void readSize(size_t& size, size_t maxSize) {
+            details::readSize(this->_adapter, size, maxSize,
+                std::integral_constant<bool, TInputAdapter::TConfig::CheckDataErrors>{});
+        }
 
         //process value types
         //false_type means that we must process all elements individually
@@ -352,14 +444,14 @@ namespace bitsery {
             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));
+                this->_adapter.template readBuffer<VSIZE>(reinterpret_cast<TIntegral*>(&(*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);
+                fnc(*this, *first);
         }
 
         //process object types
@@ -381,20 +473,26 @@ namespace bitsery {
         }
 
         //proc bool writing bit or byte, depending on if BitPackingEnabled or not
-        void procBoolValue(bool &v, std::true_type) {
+        template <typename HandleDataErrors>
+        void procBoolValue(bool &v, std::true_type, HandleDataErrors) {
             uint8_t tmp{};
-            _reader.readBits(tmp, 1);
+            this->_adapter.readBits(tmp, 1);
             v = tmp == 1;
         }
 
-        void procBoolValue(bool &v, std::false_type) {
-            unsigned char tmp;
-            _reader.template readBytes<1>(tmp);
+        void procBoolValue(bool &v, std::false_type, std::true_type) {
+            uint8_t tmp{};
+            this->_adapter.template readBytes<1>(tmp);
             if (tmp > 1)
-                _reader.setError(ReaderError::InvalidData);
+                this->_adapter.error(ReaderError::InvalidData);
             v = tmp == 1;
         }
 
+        void procBoolValue(bool &v, std::false_type, std::false_type) {
+            uint8_t tmp{};
+            this->_adapter.template readBytes<1>(tmp);
+            v = tmp > 0;
+        }
 
         //enable bit-packing or do nothing if it is already enabled
         template <typename Fnc>
@@ -404,11 +502,20 @@ namespace bitsery {
 
         template <typename Fnc>
         void procEnableBitPacking(const Fnc& fnc, std::false_type) {
-            //create serializer using bitpacking wrapper
-            BPEnabledType tmp(_reader, _context);
-            fnc(tmp);
+            //create deserializer using bitpacking wrapper
+            auto des = createWithContext(std::integral_constant<bool, Deserializer::HasContext>{});
+            fnc(des);
         }
 
+        BPEnabledType createWithContext(std::true_type) {
+            return BPEnabledType{this->_context, this->_adapter};
+        }
+
+        BPEnabledType createWithContext(std::false_type) {
+            return BPEnabledType{this->_adapter};
+        }
+
+
         //these are dummy functions for extensions that have TValue = void
         void object(details::DummyType&) {
 
@@ -419,6 +526,14 @@ namespace bitsery {
 
         }
 
+        template<typename T, typename ... TArgs>
+        void archive(T &&head, TArgs &&... tail) {
+            //serialize object
+            details::BriefSyntaxFunction<Deserializer, T>::invoke(*this, std::forward<T>(head));
+            //expand other elements
+            archive(std::forward<TArgs>(tail)...);
+        }
+
         //dummy function, that stops archive variadic arguments expansion
         void archive() {
         }
@@ -426,16 +541,20 @@ namespace bitsery {
     };
 
     //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)};
+    template <typename InputAdapter, typename T>
+    std::pair<ReaderError, bool> quickDeserialization(InputAdapter adapter, T& value) {
+        Deserializer<InputAdapter> des{std::move(adapter)};
         des.object(value);
-        auto& r = AdapterAccess::getReader(des);
-        return {r.error(), r.isCompletedSuccessfully()};
+        return {des.adapter().error(), des.adapter().isCompletedSuccessfully()};
+    }
+
+    template <typename Context , typename InputAdapter, typename T>
+    std::pair<ReaderError, bool> quickDeserialization(Context& ctx, InputAdapter adapter, T& value) {
+        Deserializer<InputAdapter, Context> des{ctx, std::move(adapter)};
+        des.object(value);
+        return {des.adapter().error(), des.adapter().isCompletedSuccessfully()};
     }
 
 }

include/bitsery/details/adapter_common.h

@@ -30,19 +30,78 @@
 #include <stack>
 #include <cstring>
 #include <climits>
-#include "adapter_utils.h"
 #include "not_defined_type.h"
 
 #include "../common.h"
 
 namespace bitsery {
 
+    enum class ReaderError {
+        NoError,
+        ReadingError, // this might be used with stream adapter
+        DataOverflow,
+        InvalidData,
+        InvalidPointer
+    };
+
     namespace details {
 
-        template<typename T>
-        struct BitsSize:public std::integral_constant<size_t, sizeof(T) * 8> {
-            static_assert(CHAR_BIT == 8, "only support systems with byte size of 8 bits");
-        };
+        /**
+         * size read/write functions
+         */
+        template <typename Reader, typename TCheckMaxSize>
+        void readSize(Reader& r, size_t& size, size_t maxSize, TCheckMaxSize) {
+            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;
+                }
+            }
+            handleReadMaxSize(r, size, maxSize, TCheckMaxSize{});
+        }
+
+        template <typename Reader>
+        void handleReadMaxSize(Reader& r, size_t& size, size_t maxSize, std::true_type) {
+            if (size > maxSize) {
+                r.error(ReaderError::InvalidData);
+                size = {};
+            }
+        }
+
+        template <typename Reader>
+        void handleReadMaxSize(Reader&, size_t&, size_t, std::false_type) {
+        }
+
+
+        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));
+                }
+            }
+        }
+
+        /**
+         * swap utils
+         */
 
         //add swap functions to class, to avoid compilation warning about unused functions
         struct SwapImpl {
@@ -83,6 +142,9 @@ namespace bitsery {
             return SwapImpl::exec(static_cast<UT>(value));
         }
 
+        /**
+         * endianness utils
+         */
         //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;
@@ -96,6 +158,16 @@ namespace bitsery {
                                                               : EndiannessType::BigEndian;
         }
 
+        template <typename Config>
+        using ShouldSwap = std::integral_constant<bool, Config::Endianness != details::getSystemEndianness()>;
+
+        /**
+         * helper types to work with bits
+         */
+        template<typename T>
+        struct BitsSize:public std::integral_constant<size_t, sizeof(T) * 8> {
+            static_assert(CHAR_BIT == 8, "only support systems with byte size of 8 bits");
+        };
 
         template<typename T>
         struct ScratchType {
@@ -107,18 +179,121 @@ namespace bitsery {
             using type = uint16_t;
         };
 
-        /*
-         * class used by session reader, to access underlying iterators of buffer
+        /**
+         * output/input adapter base that handles endianness
          */
-        struct SessionAccess {
-            template <typename TReader, typename Iterator>
-            static Iterator& posIteratorRef(TReader& r) {
-                return r.posIt;
+
+        template<typename Adapter>
+        struct OutputAdapterBaseCRTP {
+
+            static constexpr bool BitPackingEnabled = false;
+
+            template<size_t SIZE, typename T>
+            void writeBytes(const T &v) {
+                static_assert(std::is_integral<T>(), "");
+                static_assert(sizeof(T) == SIZE, "");
+                writeSwapped(&v, 1, ShouldSwap<typename Adapter::TConfig>{});
+
             }
-            template <typename TReader, typename Iterator>
-            static Iterator& endIteratorRef(TReader& r) {
-                return r.endIt;
+
+            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, "");
+                writeSwapped(buf, count, ShouldSwap<typename Adapter::TConfig>{});
             }
+
+            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.");
+            }
+
+            void align() {
+
+            }
+
+            OutputAdapterBaseCRTP() = default;
+            OutputAdapterBaseCRTP(const OutputAdapterBaseCRTP&) = delete;
+            OutputAdapterBaseCRTP& operator = (const OutputAdapterBaseCRTP&) = delete;
+            OutputAdapterBaseCRTP(OutputAdapterBaseCRTP&&) = default;
+            OutputAdapterBaseCRTP& operator = (OutputAdapterBaseCRTP&&) = default;
+
+        private:
+
+            template<typename T>
+            void writeSwapped(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);
+                    static_cast<Adapter*>(this)->writeInternal(reinterpret_cast<const typename Adapter::TValue *>(&res), sizeof(T));
+                });
+            }
+
+            template<typename T>
+            void writeSwapped(const T *v, size_t count, std::false_type) {
+                static_cast<Adapter*>(this)->writeInternal(reinterpret_cast<const typename Adapter::TValue *>(v), count * sizeof(T));
+            }
+
+        };
+
+        template <typename Base>
+        struct InputAdapterBaseCRTP {
+
+            static constexpr bool BitPackingEnabled = false;
+
+            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() {
+
+            }
+
+            InputAdapterBaseCRTP() = default;
+            InputAdapterBaseCRTP(const InputAdapterBaseCRTP&) = delete;
+            InputAdapterBaseCRTP& operator = (const InputAdapterBaseCRTP&) = delete;
+
+            InputAdapterBaseCRTP(InputAdapterBaseCRTP&&) = default;
+            InputAdapterBaseCRTP& operator = (InputAdapterBaseCRTP&&) = default;
+
+            virtual ~InputAdapterBaseCRTP() = default;
+
+        private:
+
+            template<typename T>
+            void directRead(T *v, size_t count) {
+                static_assert(!std::is_const<T>::value, "");
+                static_cast<Base*>(this)->readInternal(reinterpret_cast<typename Base::TValue *>(v), sizeof(T) * count);
+                //swap each byte if necessary
+                _swapDataBits(v, count, ShouldSwap<typename Base::TConfig>{});
+            }
+
+            template<typename T>
+            void _swapDataBits(T *v, size_t count, std::true_type) {
+                std::for_each(v, std::next(v, count), [](T &x) { x = details::swap(x); });
+            }
+
+            template<typename T>
+            void _swapDataBits(T *, size_t , std::false_type) {
+                //empty function because no swap is required
+            }
+
         };
 
     }

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/brief_syntax_common.h

@@ -20,14 +20,14 @@
 //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
+#ifndef BITSERY_DETAILS_BRIEF_SYNTAX_COMMON_H
+#define BITSERY_DETAILS_BRIEF_SYNTAX_COMMON_H
 
 #include "../traits/core/traits.h"
 #include <limits>
 
 namespace bitsery {
-    namespace flexible {
+    namespace brief_syntax {
 
         //these function overloads is required to apply maxSize, and optimize for fundamental types
         //for contigous arrays of fundamenal types, memcpy will be applied
@@ -84,13 +84,13 @@ namespace bitsery {
 
 
         //all wrapper functions, that modify behaviour, should inherit from this
-        struct ArchiveWrapperFnc {
+        struct ModFnc {
 
         };
 
         //this type is used to differentiate between container and text behaviour
         template<typename T, size_t N, bool isText>
-        struct CArray : public ArchiveWrapperFnc {
+        struct CArray : public ModFnc {
             CArray(T (&data_)[N]) : data{data_} {};
             T (&data)[N];
         };
@@ -107,7 +107,7 @@ namespace bitsery {
 
         //used to set max container size
         template<typename T>
-        struct MaxSize : public ArchiveWrapperFnc {
+        struct MaxSize : public ModFnc {
             MaxSize(T &data_, size_t maxSize_) : data{data_}, maxSize{maxSize_} {};
             T &data;
             size_t maxSize;
@@ -146,4 +146,4 @@ namespace bitsery {
     }
 }
 
-#endif //BITSERY_DETAILS_FLEXIBLE_COMMON_H
+#endif //BITSERY_DETAILS_BRIEF_SYNTAX_COMMON_H

include/bitsery/details/not_defined_type.h

@@ -35,7 +35,7 @@ namespace bitsery {
             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
+            //this time will be used as iterator, so define all operators necessary to work with iterators
             friend bool operator == (const NotDefinedType&, const NotDefinedType&) {
                 return true;
             }
@@ -56,7 +56,7 @@ namespace bitsery {
             int& operator*() {
                 return data;
             }
-            int data;
+            int data{};
         };
 
         template <typename T>

include/bitsery/details/serialization_common.h

@@ -26,23 +26,67 @@
 #include <type_traits>
 #include <utility>
 #include <tuple>
-#include "adapter_utils.h"
+#include "adapter_common.h"
 #include "../traits/core/traits.h"
 
 
 namespace bitsery {
 
-    //this allows to call private serialize method for the class
-    //just make friend it to that class
-    struct Access {
+    //this allows to call private serialize method, and construct instance (if no default constructor is provided) for your type
+    //just make friend it in your class
+    class Access {
+    public:
         template<typename S, typename T>
         static auto serialize(S &s, T &obj) -> decltype(obj.serialize(s)) {
             obj.serialize(s);
         }
+
+        template <typename T>
+        static T create() {
+            //if you get an error here, please create default constructor
+            return T{};
+        }
+        template <typename T>
+        static T* create(void* ptr) {
+            return new(ptr) T{};
+        }
+
     };
 
+
+    // convenient functors that can be passed as lambda to serializer/deserializer instead of writing lambda
+    // e.g. instead of writing this:
+    // s.container(c, 100, [](S& s, float& v) { s.ext4b(v, CompactValue{});});
+    // you can write like this
+    // s.container(c, 100, FtorExtValue2b<CompactValue>{});
+    template<size_t N, typename Ext>
+    struct FtorExtValue : public Ext {
+        template <typename S, typename T>
+        void operator()(S& s, T& v) const {
+            s.template ext<N>(v, static_cast<const Ext&>(*this));
+        }
+    };
+
+    template <typename Ext>
+    struct FtorExtValue1b: FtorExtValue<1, Ext> {};
+    template <typename Ext>
+    struct FtorExtValue2b: FtorExtValue<2, Ext> {};
+    template <typename Ext>
+    struct FtorExtValue4b: FtorExtValue<4, Ext> {};
+    template <typename Ext>
+    struct FtorExtValue8b: FtorExtValue<8, Ext> {};
+
+    template<typename Ext>
+    struct FtorExtObject : public Ext {
+        template <typename S, typename T>
+        void operator()(S& s, T& v) const {
+            s.ext(v, static_cast<const Ext&>(*this));
+        }
+    };
+
+
     //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
+    //specialize this class by inheriting from either UseNonMemberFnc or UseMemberFnc
     //e.g.
     //template <> struct SelectSerializeFnc<MyDerivedClass>:UseMemberFnc {};
     template<typename T>
@@ -55,23 +99,6 @@ namespace bitsery {
     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;
-        }
-
-        template<typename Deserializer>
-        static typename Deserializer::TReader &getReader(Deserializer &s) {
-            return s._reader;
-        }
-    };
-
     namespace details {
 
         //helper types for error handling
@@ -116,20 +143,20 @@ namespace bitsery {
         template <typename S, typename T>
         struct HasSerializeMethod :HasSerializeMethodHelper<S, T>::type {};
 
-        //helper types for IsFlexibleIncluded
+        //helper types for IsBriefSyntaxIncluded
         template <typename S, typename T>
-        using TryArchiveProcess = decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()));
+        using TryProcessBriefSyntax = decltype(processBriefSyntax(std::declval<S &>(), std::declval<T &&>()));
 
         template <typename S, typename T>
-        struct IsFlexibleIncludedHelper {
-            template <typename Q, typename R, typename = TryArchiveProcess<Q, R>>
+        struct IsBriefSyntaxIncludedHelper {
+            template <typename Q, typename R, typename = TryProcessBriefSyntax<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 IsFlexibleIncluded :IsFlexibleIncludedHelper<S, T>::type {};
+        struct IsBriefSyntaxIncluded :IsBriefSyntaxIncludedHelper<S, T>::type {};
 #else
         //helper metafunction, that is added to c++17
         template<typename... Ts>
@@ -162,23 +189,23 @@ namespace bitsery {
 
         //this solution doesn't work with visual studio, but is more elegant
         template<typename, typename, typename = void>
-        struct IsFlexibleIncluded : std::false_type {
+        struct IsBriefSyntaxIncluded : std::false_type {
         };
 
         template<typename S, typename T>
-        struct IsFlexibleIncluded<S, T,
-                void_t<decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()))>
+        struct IsBriefSyntaxIncluded<S, T,
+                void_t<decltype(processBriefSyntax(std::declval<S &>(), std::declval<T &&>()))>
         > : std::true_type {
         };
 #endif
 
 
-        //used for extensions, when extension TValue = void
+        //used for extensions when extension TValue = void
         struct DummyType {
         };
 
 /*
- * this includes all integral types floats and enums(except bool)
+ * this includes all integral types, floats and enums(except bool)
  */
         template<typename T>
         struct IsFundamentalType : std::integral_constant<bool,
@@ -230,6 +257,10 @@ namespace bitsery {
                 selectSerializeFnc(s, v, SelectSerializeFnc<TDecayed>{});
             }
 
+            static constexpr bool isDefined() {
+                return HasSerializeFunction<S, T>::value || HasSerializeMethod<S, T>::value;
+            }
+
         private:
             static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 0>) {
                 static_assert(!(HasSerializeFunction<S, T>::value && HasSerializeMethod<S, T>::value),
@@ -255,13 +286,13 @@ namespace bitsery {
  */
 
         template<typename S, typename T, typename Enabled = void>
-        struct ArchiveFunction {
+        struct BriefSyntaxFunction {
 
             static void invoke(S &s, T &&obj) {
-                static_assert(IsFlexibleIncluded<S, T>::value,
-                              "\nPlease include '<bitsery/flexible.h>' to use 'archive' function:\n");
+                static_assert(IsBriefSyntaxIncluded<S, T>::value,
+                              "\nPlease include '<bitsery/brief_syntax.h>' to use operator():\n");
 
-                archiveProcess(s, std::forward<T>(obj));
+                processBriefSyntax(s, std::forward<T>(obj));
             }
         };
 
@@ -269,6 +300,156 @@ namespace bitsery {
          * helper function for getting context from serializer/deserializer
          */
 
+        template<int Index, typename... Conds>
+        struct FindIndex : std::integral_constant<int, Index> {};
+
+        template<int Index, typename Cond, typename... Conds>
+        struct FindIndex<Index, Cond, Conds...> :
+            std::conditional<Cond::value, std::integral_constant<int, Index>, FindIndex<Index+1, Conds...>>::type
+        {};
+
+        template <typename T, typename Tuple>
+        struct GetConvertibleTypeIndexFromTuple;
+
+        template <typename T, typename... Us>
+        struct GetConvertibleTypeIndexFromTuple<T, std::tuple<Us...>> : FindIndex<0, std::is_convertible<Us&, T&>...> {};
+
+
+        template <typename T, typename Tuple>
+        struct IsExistsConvertibleTupleType;
+
+        template <typename T, typename... Us>
+        struct IsExistsConvertibleTupleType<T, std::tuple<Us...>> :
+            std::integral_constant<bool, GetConvertibleTypeIndexFromTuple<T, std::tuple<Us...>>::value != sizeof...(Us)> {};
+
+
+        /*
+         * get context from internal or external, and check if it's convertible or not
+         */
+
+
+        template<bool AssertExists, typename TCast, typename TContext>
+        TCast* getDirectlyIfExists(TContext& ctx, std::true_type) {
+            return &static_cast<TCast&>(ctx);
+        }
+
+        template<bool AssertExists, typename TCast, typename TContext>
+        TCast* getDirectlyIfExists(TContext& , std::false_type) {
+            // TCast cannot be convertible from provided context
+            static_assert(!AssertExists,
+                          "Invalid context cast. Context type doesn't exists.\nSome functionality requires (de)seserializer to have specific context.");
+            return nullptr;
+        }
+
+
+        template<bool AssertExists, typename TCast, typename ... TArgs>
+        TCast* getFromTupleIfExists(std::tuple<TArgs...>& ctx, std::true_type) {
+            using TupleIndex = GetConvertibleTypeIndexFromTuple<TCast, std::tuple<TArgs...>>;
+            return &static_cast<TCast&>(std::get<TupleIndex::value>(ctx));
+        }
+
+        template<bool AssertExists, typename TCast, typename ... TArgs>
+        TCast* getFromTupleIfExists(std::tuple<TArgs...>& , std::false_type) {
+            // TCast cannot be convertible from provided context
+            static_assert(!AssertExists,
+                "Invalid context cast. Context type doesn't exists.\nSome functionality requires (de)seserializer to have specific context.");
+            return nullptr;
+        }
+
+        //non tuple context
+        template<bool AssertExists, typename TCast, typename TContext>
+        TCast* getContext(TContext& ctx) {
+            return getDirectlyIfExists<AssertExists, TCast>(ctx, std::is_convertible<TContext&, TCast&>{});
+        }
+
+        //tuple context
+        template<bool AssertExists, typename TCast, typename ... TArgs>
+        TCast* getContext(std::tuple<TArgs...>& ctx) {
+            return getFromTupleIfExists<AssertExists, TCast>(ctx, IsExistsConvertibleTupleType<TCast, std::tuple<TArgs...>>{});
+        }
+
+        template <typename Adapter, typename Context>
+        class AdapterAndContextRef {
+        public:
+            static constexpr bool HasContext = true;
+            using Config = typename Adapter::TConfig;
+
+            // constructing adapter in place is important,
+            // because enableBitPacking might create instance with bit write/read enabled adapter wrapper,
+            // which has non trivial destructor
+            template <typename ... TArgs>
+            explicit AdapterAndContextRef(Context& ctx, TArgs&& ... args)
+                : _adapter{std::forward<TArgs>(args)...},
+                  _context{ctx}
+            {
+            }
+
+            /*
+             * get serialization context.
+             * this is optional, but might be required for some specific serialization flows.
+             */
+
+            template <typename T>
+            T& context() {
+                return *getContext<true, T>(_context);
+            }
+
+            template <typename T>
+            T* contextOrNull() {
+                return getContext<false, T>(_context);
+            }
+
+            Adapter& adapter() & {
+                return _adapter;
+            }
+
+            Adapter adapter() && {
+                return std::move(_adapter);
+            }
+
+        protected:
+            Adapter _adapter;
+            Context& _context;
+        };
+
+        template <typename Adapter>
+        class AdapterAndContextRef<Adapter, void> {
+        public:
+            static constexpr bool HasContext = false;
+            using Config = typename Adapter::TConfig;
+
+            template <typename ... TArgs>
+            explicit AdapterAndContextRef(TArgs&& ... args)
+                : _adapter{std::forward<TArgs>(args)...}
+            {
+            }
+
+            template <typename T>
+            T& context() {
+                static_assert(std::is_void<T>::value, "Context is not defined (is void).");
+            }
+
+            template <typename T>
+            T* contextOrNull() {
+                return nullptr;
+            }
+
+            Adapter& adapter() & {
+                return _adapter;
+            }
+
+            Adapter adapter() && {
+                return std::move(_adapter);
+            }
+
+        protected:
+            Adapter _adapter;
+        };
+
+/**
+ * other helper meta-functions
+ */
+
         template<typename T, template<typename...> class Template>
         struct IsSpecializationOf : std::false_type {
         };
@@ -277,123 +458,6 @@ namespace bitsery {
         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>{});
-        }
-
     }
 }
 

include/bitsery/details/sessions.h

@@ -1,246 +0,0 @@
-//MIT License
-//
-//Copyright (c) 2018 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_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/compact_value.h

@@ -35,46 +35,46 @@ namespace bitsery {
         class CompactValueImpl {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &s, Writer &writer, const T &v, Fnc &&) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &s, const T &v, Fnc &&) const {
                 static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
                 using TValue = typename IntegralFromFundamental<T>::TValue;
-                serializeImpl(s, writer, reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
+                serializeImpl(s.adapter(), reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &d, Reader &reader, T &v, Fnc &&) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &d, T &v, Fnc &&) const {
                 static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
                 using TValue = typename IntegralFromFundamental<T>::TValue;
-                deserializeImpl(d, reader, reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
+                deserializeImpl(d.adapter(), reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
             }
 
         private:
 
             // if value is 1byte size, just serialize/ deserialize whole value
-            template<typename Ser, typename Writer, typename T>
-            void serializeImpl(Ser &s, Writer &, const T &v, std::false_type) const {
-                s.value1b(v);
+            template<typename Writer, typename T>
+            void serializeImpl(Writer &writer, const T &v, std::false_type) const {
+                writer.template writeBytes<1>(v);
             }
 
-            template<typename Des, typename Reader, typename T>
-            void deserializeImpl(Des &d, Reader &, T &v, std::false_type) const {
-                d.value1b(v);
+            template<typename Reader, typename T>
+            void deserializeImpl(Reader &reader, T &v, std::false_type) const {
+                reader.template readBytes<1>(v);
             }
 
             // when value is bigger than 1byte size,
-            template<typename Ser, typename Writer, typename T>
-            void serializeImpl(Ser &, Writer &writer, const T &v, std::true_type) const {
+            template<typename Writer, typename T>
+            void serializeImpl(Writer &writer, const T &v, std::true_type) const {
                 auto val = zigZagEncode(v, std::is_signed<typename IntegralFromFundamental<T>::TValue>{});
                 writeBytes(writer, val);
             }
 
 
-            template<typename Des, typename Reader, typename T>
-            void deserializeImpl(Des &, Reader &reader, T &v, std::true_type) const {
+            template<typename Reader, typename T>
+            void deserializeImpl(Reader &reader, T &v, std::true_type) const {
                 using TUnsigned = SameSizeUnsigned<T>;
                 TUnsigned res{};
-                readBytes(reader, res);
+                readBytes<Reader::TConfig::CheckDataErrors>(reader, res);
                 v = zigZagDecode<T>(res, std::is_signed<typename IntegralFromFundamental<T>::TValue>{});
             }
 
@@ -96,7 +96,7 @@ namespace bitsery {
 
             template<typename TResult, typename TUnsigned>
             TResult zigZagDecode(TUnsigned v, std::true_type) const {
-                return (v >> 1) ^ -(v & 1);
+                return (v >> 1) ^ (~(v & 1) + 1); // same as -(v & 1), but no warning on VisualStudio
             }
 
             // write/read bytes one by one
@@ -110,7 +110,7 @@ namespace bitsery {
                 w.template writeBytes<1>(static_cast<uint8_t>(val));
             }
 
-            template<typename Reader, typename T>
+            template<bool CheckErrors, typename Reader, typename T>
             void readBytes(Reader &r, T &v) const {
                 constexpr auto TBITS = sizeof(T)*8;
                 uint8_t b1{0x80u};
@@ -119,18 +119,19 @@ namespace bitsery {
                     r.template readBytes<1>(b1);
                     v += static_cast<T>(b1 & 0x7Fu) << i;
                 }
-                checkReadOverflow<Reader, T>(r, i, b1, std::integral_constant<bool, CheckOverflow>{});
+                handleReadOverflow<Reader, T>(r, i, b1,
+                                              std::integral_constant<bool, CheckOverflow && CheckErrors>{});
             }
             template <typename Reader, typename T>
-            void checkReadOverflow(Reader &r, unsigned shiftedBy, uint8_t remainder, std::true_type) const {
+            void handleReadOverflow(Reader& r, unsigned shiftedBy, uint8_t remainder, std::true_type) const {
                 constexpr auto TBITS = sizeof(T)*8;
                 if (shiftedBy > TBITS && remainder >> (TBITS + 7 - shiftedBy)) {
-                    r.setError(bitsery::ReaderError::DataOverflow);
+                    r.error(bitsery::ReaderError::InvalidData);
                 }
             }
 
             template <typename Reader, typename T>
-            void checkReadOverflow(Reader &, unsigned , uint8_t , std::false_type) const {
+            void handleReadOverflow(Reader &, unsigned , uint8_t , std::false_type) const {
 
             }
 
@@ -149,6 +150,7 @@ namespace bitsery {
     }
 
     namespace traits {
+
         template<typename T>
         struct ExtensionTraits<ext::CompactValue, T> {
             using TValue = T;
@@ -168,6 +170,14 @@ namespace bitsery {
             static constexpr bool SupportLambdaOverload = false;
         };
 
+        template<typename T, bool Check>
+        struct ExtensionTraits<details::CompactValueImpl<Check>, T> {
+            using TValue = T;
+            static constexpr bool SupportValueOverload = !Check;
+            static constexpr bool SupportObjectOverload = Check;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
     }
 
 }

include/bitsery/ext/entropy.h

@@ -56,28 +56,28 @@ namespace bitsery {
                       _alignBeforeData{alignBeforeData} {
             };
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &s, Writer &, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &s, 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();
+                    s.adapter().align();
                 if (!index)
-                    fnc(const_cast<T &>(obj));
+                    fnc(s, const_cast<T &>(obj));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &d, Reader &, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &d, 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();
+                    d.adapter().align();
                 if (index)
                     obj = *std::next(std::begin(_values), index-1);
                 else
-                    fnc(obj);
+                    fnc(d, obj);
             }
 
         private:

include/bitsery/ext/growable.h

@@ -30,23 +30,40 @@ namespace bitsery {
     namespace ext {
 
         /*
-         * enables to add additional serialization methods at the end of method, without breaking existing older code
+         * enables forward and backward compatibility, by allowing to append additional data at the end of serialization
+         * old deserialization method will ignore additional data by jumping through it at the end of deserialization flow
+         * new deserialization method will read all 0 for new fields if there is no data for it
          */
         class Growable {
         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();
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
+                auto& writer = ser.adapter();
+                const auto startPos = writer.currentWritePos();
+                writer.template writeBytes<4>(static_cast<uint32_t>(0));
+
+                fnc(ser, const_cast<T&>(obj));
+
+                const auto endPos = writer.currentWritePos();
+                writer.currentWritePos(startPos);
+                writer.template writeBytes<4>(static_cast<uint32_t>(endPos - startPos));
+                writer.currentWritePos(endPos);
             }
 
-            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 Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
+                auto& reader = des.adapter();
+                uint32_t size{};
+                const auto readEndPos = reader.currentReadEndPos();
+                const auto startPos = reader.currentReadPos();
+                reader.template readBytes<4>(size);
+                reader.currentReadEndPos(startPos + size);
+
+                fnc(des, obj);
+
+                reader.currentReadPos(startPos + size);
+                reader.currentReadEndPos(readEndPos);
             }
         };
     }

include/bitsery/ext/inheritance.h

@@ -25,6 +25,7 @@
 
 #include <unordered_set>
 #include "../traits/core/traits.h"
+#include "bitsery/ext/utils/memory_resource.h"
 
 namespace bitsery {
 
@@ -34,7 +35,9 @@ namespace bitsery {
         //for standard inheritance (ext::BaseClass) it is optional.
         class InheritanceContext {
         public:
-            InheritanceContext() = default;
+            explicit InheritanceContext(MemResourceBase* memResource = nullptr)
+                :_virtualBases{pointer_utils::StdPolyAlloc<const void*>{memResource}}
+                {}
             InheritanceContext(const InheritanceContext&) = delete;
             InheritanceContext&operator = (const InheritanceContext&) = delete;
             InheritanceContext(InheritanceContext&&) = default;
@@ -66,34 +69,37 @@ namespace bitsery {
             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{};
+            std::unordered_set<const void*,
+                std::hash<const void*>, std::equal_to<const void*>,
+                pointer_utils::StdPolyAlloc<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 {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, 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));
+                    fnc(ser, const_cast<TBase&>(resObj));
                     ctx->end();
                 } else {
-                    fnc(const_cast<TBase&>(resObj));
+                    fnc(ser, const_cast<TBase&>(resObj));
                 }
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 auto& resObj = static_cast<TBase&>(obj);
                 if (auto ctx = des.template contextOrNull<InheritanceContext>()) {
                     ctx->beginBase(obj, resObj);
-                    fnc(resObj);
+                    fnc(des, resObj);
                     ctx->end();
                 } else {
-                    fnc(resObj);
+                    fnc(des, resObj);
                 }
             }
 
@@ -104,22 +110,22 @@ namespace bitsery {
         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>();
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, 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();
+                if (ctx.beginVirtualBase(obj, resObj))
+                    fnc(ser, 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>();
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, 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();
+                if (ctx.beginVirtualBase(obj, resObj))
+                    fnc(des, resObj);
+                ctx.end();
             }
 
         };

include/bitsery/ext/pointer.h

@@ -41,7 +41,7 @@ namespace bitsery {
 
                 using TElement = typename std::remove_pointer<T>::type;
 
-                static TElement* getPtr(T &obj) {
+                static TElement* getPtr(T& obj) {
                     return obj;
                 }
 
@@ -49,15 +49,26 @@ namespace bitsery {
                     return PointerOwnershipType::Owner;
                 }
 
-                static void assign(T& obj, TElement* valuePtr) {
-                    delete obj;
-                    obj = valuePtr;
+                static void create(T& obj, pointer_utils::PolyAllocWithTypeId alloc, size_t typeId) {
+                    obj = alloc.newObject<TElement>(typeId);
                 }
 
-                static void clear(T& obj) {
-                    delete obj;
+                static void createPolymorphic(T& obj, pointer_utils::PolyAllocWithTypeId alloc,
+                                              const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    obj = static_cast<TElement*>(handler->create(alloc));
+                }
+
+                static void destroy(T& obj, pointer_utils::PolyAllocWithTypeId alloc, size_t typeId) {
+                    alloc.deleteObject(obj, typeId);
                     obj = nullptr;
                 }
+
+                static void destroyPolymorphic(T& obj, pointer_utils::PolyAllocWithTypeId alloc,
+                                               const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    handler->destroy(alloc, obj);
+                    obj = nullptr;
+                }
+
             };
 
             template<typename T>
@@ -66,11 +77,6 @@ namespace bitsery {
 
                 using TElement = typename std::remove_pointer<T>::type;
 
-                //observer must return reference to pointer, so that it could be updated later
-                static TElement*& getPtrRef(T& obj) {
-                    return obj;
-                }
-
                 static TElement* getPtr(T& obj) {
                     return obj;
                 }
@@ -79,12 +85,17 @@ namespace bitsery {
                     return PointerOwnershipType::Observer;
                 }
 
-                static void assign(T& obj, TElement* valuePtr) {
-                    //do not delete existing object
-                    obj = valuePtr;
+                //pure observer doesn't have create/createPolymorphic methods, but instead returns reference to pointer
+                //which gets updated later
+                static TElement*& getPtrRef(T& obj) {
+                    return obj;
                 }
 
-                static void clear(T& obj) {
+                static void destroy(T& obj, MemResourceBase* , size_t ) {
+                    obj = nullptr;
+                }
+
+                static void destroyPolymorphic(T& obj, MemResourceBase* , PolymorphicHandlerBase& ) {
                     obj = nullptr;
                 }
 
@@ -107,9 +118,22 @@ namespace bitsery {
 
                 // this code is unreachable for reference type, but is necessary to compile
                 // LCOV_EXCL_START
-                static void assign(T& , TElement* ) {}
 
-                static void clear(T& ) {}
+                static void create(T& , MemResourceBase* , size_t ) {
+
+                }
+
+                static void createPolymorphic(T& , MemResourceBase* , PolymorphicHandlerBase& ) {
+
+                }
+
+                static void destroy(T& , MemResourceBase* , size_t ) {
+
+                }
+
+                static void destroyPolymorphic(T& , MemResourceBase* , PolymorphicHandlerBase& ) {
+
+                }
                 // LCOV_EXCL_STOP
 
             };
@@ -117,7 +141,7 @@ namespace bitsery {
             // this class is used by NonPtrManager
             struct NoRTTI {
                 template<typename TBase>
-                static size_t get(TBase& ) {
+                static size_t get(TBase&) {
                     return 0;
                 }
 
@@ -142,20 +166,20 @@ namespace bitsery {
 
         template<typename RTTI>
         using PointerOwnerBase = pointer_utils::PointerObjectExtensionBase<
-                pointer_details::PtrOwnerManager, PolymorphicContext, RTTI>;
+            pointer_details::PtrOwnerManager, PolymorphicContext, RTTI>;
 
         using PointerOwner = PointerOwnerBase<StandardRTTI>;
 
         using PointerObserver = pointer_utils::PointerObjectExtensionBase<
-                pointer_details::PtrObserverManager, PolymorphicContext, pointer_details::NoRTTI>;
+            pointer_details::PtrObserverManager, PolymorphicContext, pointer_details::NoRTTI>;
 
         //inherit from PointerObjectExtensionBase in order to specify PointerType::NotNull
         class ReferencedByPointer : public pointer_utils::PointerObjectExtensionBase<
-                pointer_details::NonPtrManager, PolymorphicContext, pointer_details::NoRTTI> {
+            pointer_details::NonPtrManager, PolymorphicContext, pointer_details::NoRTTI> {
         public:
             ReferencedByPointer() : pointer_utils::PointerObjectExtensionBase<
-                    pointer_details::NonPtrManager, PolymorphicContext, pointer_details::NoRTTI>(
-                    PointerType::NotNull) {}
+                pointer_details::NonPtrManager, PolymorphicContext, pointer_details::NoRTTI>(
+                PointerType::NotNull) {}
         };
 
     }

include/bitsery/ext/std_chrono.h

@@ -0,0 +1,94 @@
+//MIT License
+//
+//Copyright (c) 2019 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_CHRONO_H
+#define BITSERY_EXT_STD_CHRONO_H
+
+#include "../traits/core/traits.h"
+#include <chrono>
+
+namespace bitsery {
+    namespace ext {
+
+        class StdDuration {
+        public:
+
+            template<typename Ser, typename T, typename Period, typename Fnc>
+            void serialize(Ser& ser, const std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
+                auto res = obj.count();
+                fnc(ser, res);
+            }
+
+            template<typename Des, typename T, typename Period, typename Fnc>
+            void deserialize(Des& des, std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
+                T res{};
+                fnc(des, res);
+                obj = std::chrono::duration<T, Period>{res};
+            }
+        };
+
+        class StdTimePoint {
+        public:
+
+            template<typename Ser, typename Clock, typename T, typename Period, typename Fnc>
+            void serialize(Ser& ser, const std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
+                           Fnc&& fnc) const {
+                auto res = obj.time_since_epoch().count();
+                fnc(ser, res);
+            }
+
+            template<typename Des, typename Clock, typename T, typename Period, typename Fnc>
+            void deserialize(Des& des, std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
+                             Fnc&& fnc) const {
+                T res{};
+                fnc(des, res);
+                auto dur = std::chrono::duration<T, Period>{res};
+                obj = std::chrono::time_point<Clock, std::chrono::duration<T, Period>>{dur};
+            }
+        };
+
+    }
+
+    namespace traits {
+        template<typename Rep, typename Period>
+        struct ExtensionTraits<ext::StdDuration, std::chrono::duration<Rep, Period>> {
+            using TValue = Rep;
+            static constexpr bool SupportValueOverload = true;
+            static constexpr bool SupportObjectOverload = false;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+        template<typename Clock, typename Rep, typename Period>
+        struct ExtensionTraits<ext::StdTimePoint,
+            std::chrono::time_point<Clock, std::chrono::duration<Rep, Period>>> {
+            using TValue = Rep;
+            static constexpr bool SupportValueOverload = true;
+            static constexpr bool SupportObjectOverload = false;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+    }
+
+}
+
+
+#endif //BITSERY_EXT_STD_CHRONO_H

include/bitsery/ext/std_map.h

@@ -24,7 +24,10 @@
 #define BITSERY_EXT_STD_MAP_H
 
 #include "../traits/core/traits.h"
-#include "../details/adapter_utils.h"
+#include "../details/adapter_common.h"
+#include "../details/serialization_common.h"
+//we need this, so we could reserve for non ordered map
+#include <unordered_map>
 
 namespace bitsery {
     namespace ext {
@@ -34,36 +37,50 @@ namespace bitsery {
 
             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 {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, 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);
+                details::writeSize(ser.adapter(), size);
 
                 for (auto &v:obj)
-                    fnc(const_cast<TKey &>(v.first), const_cast<TValue &>(v.second));
+                    fnc(ser, 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 {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, 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();
+                details::readSize(des.adapter(), size, _maxSize,
+                    std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
                 obj.clear();
+                reserve(obj, size);
 
+                auto hint = obj.begin();
                 for (auto i = 0u; i < size; ++i) {
-                    TKey key;
-                    TValue value;
-                    fnc(key, value);
+                    auto key{bitsery::Access::create<TKey>()};
+                    auto value{bitsery::Access::create<TValue>()};
+                    fnc(des, key, value);
                     hint = obj.emplace_hint(hint, std::move(key), std::move(value));
                 }
             }
         private:
+            template <typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
+            void reserve(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& obj, size_t size) const {
+                obj.reserve(size);
+            }
+            template <typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
+            void reserve(std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>& 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;
         };
     }

include/bitsery/ext/std_optional.h

@@ -24,23 +24,13 @@
 #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"
+#include "../details/serialization_common.h"
+#include <optional>
 
 namespace bitsery {
     namespace ext {
 
-        template<typename T>
-        using std_optional = ::std::optional<T>;
-
         class StdOptional {
         public:
 
@@ -49,38 +39,27 @@ namespace bitsery {
              * @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>();
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const std::optional<T> &obj, Fnc &&fnc) const {
                 ser.boolValue(static_cast<bool>(obj));
                 if (_alignBeforeData)
-                    ser.align();
+                    ser.adapter().align();
                 if (obj)
-                    fnc(const_cast<typename T::value_type & >(*obj));
+                    fnc(ser, const_cast<T&>(*obj));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
-                assertType<T>();
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, std::optional<T> &obj, Fnc &&fnc) const {
                 bool exists{};
                 des.boolValue(exists);
                 if (_alignBeforeData)
-                    des.align();
+                    des.adapter().align();
                 if (exists) {
-                    typename T::value_type tmp{};
-                    fnc(tmp);
-                    obj = tmp;
+                    obj = ::bitsery::Access::create<T>();
+                    fnc(des, *obj);
                 } else {
-                    //experimental optional doesnt have .reset method
-                    obj = T{};
+                    obj = std::nullopt;
                 }
             }
         private:
@@ -90,8 +69,8 @@ namespace bitsery {
 
     namespace traits {
         template<typename T>
-        struct ExtensionTraits<ext::StdOptional, T> {
-            using TValue = typename T::value_type;
+        struct ExtensionTraits<ext::StdOptional, std::optional<T>> {
+            using TValue = T;
             static constexpr bool SupportValueOverload = true;
             static constexpr bool SupportObjectOverload = true;
             static constexpr bool SupportLambdaOverload = true;

include/bitsery/ext/std_queue.h

@@ -51,15 +51,15 @@ namespace bitsery {
                 }
             };
             //inherit from queue so we could take underlying container
-            template <typename T, typename C>
-            struct PriorityQueueCnt : public std::priority_queue<T, C>
+            template <typename T, typename Seq, typename Cmp>
+            struct PriorityQueueCnt : public std::priority_queue<T, Seq, Cmp>
             {
-                static const C& getContainer(const std::priority_queue<T, C>& s )
+                static const Seq& getContainer(const std::priority_queue<T, Seq, Cmp>& s )
                 {
                     //get address of underlying container
                     return s.*(&PriorityQueueCnt::c);
                 }
-                static C& getContainer(std::priority_queue<T, C>& s )
+                static Seq& getContainer(std::priority_queue<T, Seq, Cmp>& s )
                 {
                     //get address of underlying container
                     return s.*(&PriorityQueueCnt::c);
@@ -71,25 +71,25 @@ namespace bitsery {
             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 {
+            template<typename Ser, typename T, typename C, typename Fnc>
+            void serialize(Ser &ser, 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 {
+            template<typename Des, typename T, typename C, typename Fnc>
+            void deserialize(Des &des, 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 Ser, typename T, typename C, typename Comp, typename Fnc>
+            void serialize(Ser &ser, const std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
+                ser.container(PriorityQueueCnt<T,C, Comp>::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));
+            template<typename Des, typename T, typename C, typename Comp, typename Fnc>
+            void deserialize(Des &des, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
+                des.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
         };

include/bitsery/ext/std_set.h

@@ -24,10 +24,10 @@
 #define BITSERY_EXT_STD_SET_H
 
 #include <cassert>
-#include "../details/adapter_utils.h"
+#include "../details/adapter_common.h"
+#include "../details/serialization_common.h"
 //we need this, so we could reserve for non ordered set
 #include <unordered_set>
-#include "../traits/core/traits.h"
 
 namespace bitsery {
     namespace ext {
@@ -37,43 +37,45 @@ namespace bitsery {
 
             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 {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
                 auto size = obj.size();
                 assert(size <= _maxSize);
-                details::writeSize(writer, size);
+                details::writeSize(ser.adapter(), size);
 
                 for (auto &v:obj)
-                    fnc(const_cast<TKey &>(v));
+                    fnc(ser, const_cast<TKey &>(v));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
 
                 size_t size{};
-                details::readSize(reader, size, _maxSize);
-                auto hint = obj.begin();
+                details::readSize(des.adapter(), size, _maxSize, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
                 obj.clear();
                 reserve(obj, size);
-
+                auto hint = obj.begin();
                 for (auto i = 0u; i < size; ++i) {
-                    TKey key;
-                    fnc(key);
+                    auto key{bitsery::Access::create<TKey>()};
+                    fnc(des, key);
                     hint = obj.emplace_hint(hint, std::move(key));
                 }
             }
         private:
 
-            template <typename T>
-            void reserve(std::unordered_set<T>& obj, size_t size) const {
+            template <typename Key, typename Hash, typename KeyEqual, typename Allocator>
+            void reserve(std::unordered_set<Key, Hash, KeyEqual, Allocator>& obj, size_t size) const {
                 obj.reserve(size);
             }
-            template <typename T>
-            void reserve(std::unordered_multiset<T>& obj, size_t size) const {
+            template <typename Key, typename Hash, typename KeyEqual, typename Allocator>
+            void reserve(std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& obj, size_t size) const {
                 obj.reserve(size);
             }
+
+
+
             template <typename T>
             void reserve(T& , size_t ) const {
                 //for ordered container do nothing

include/bitsery/ext/std_smart_ptr.h

@@ -46,56 +46,126 @@ namespace bitsery {
 
                 using TElement = typename T::element_type;
 
-                static TElement *getPtr(std::unique_ptr<TElement> &obj) {
+                template<typename TDeleter>
+                static TElement* getPtr(std::unique_ptr<TElement, TDeleter>& obj) {
                     return obj.get();
                 }
 
-                static TElement *getPtr(std::shared_ptr<TElement> &obj) {
+                static TElement* getPtr(std::shared_ptr<TElement>& obj) {
                     return obj.get();
                 }
 
-                static TElement *getPtr(std::weak_ptr<TElement> &obj) {
+                static TElement* getPtr(std::weak_ptr<TElement>& obj) {
                     if (auto ptr = obj.lock())
                         return ptr.get();
                     return nullptr;
                 }
 
                 static constexpr PointerOwnershipType getOwnership() {
-                    return std::is_same<std::unique_ptr<TElement>, T>::value
+                    return ::bitsery::details::IsSpecializationOf<T, std::unique_ptr>::value
                            ? PointerOwnershipType::Owner
                            : std::is_same<std::shared_ptr<TElement>, T>::value
                              ? PointerOwnershipType::SharedOwner
                              : PointerOwnershipType::SharedObserver;
                 }
 
-                static void clear(T &obj) {
+                template<typename TDeleter>
+                static void create(std::unique_ptr<TElement, TDeleter>& obj, pointer_utils::PolyAllocWithTypeId alloc,
+                                   size_t typeId) {
+                    obj.reset(alloc.newObject<TElement>(typeId));
+                }
+
+                template<typename TDeleter>
+                static void createPolymorphic(std::unique_ptr<TElement, TDeleter>& obj, pointer_utils::PolyAllocWithTypeId alloc,
+                                              const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    obj.reset(static_cast<TElement*>(handler->create(alloc)));
+                }
+
+                template<typename TDel>
+                static void destroy(std::unique_ptr<TElement, TDel>& obj, pointer_utils::PolyAllocWithTypeId alloc, size_t typeId) {
+                    auto ptr = obj.release();
+                    alloc.deleteObject(ptr, typeId);
+                }
+
+                template<typename TDel>
+                static void destroyPolymorphic(std::unique_ptr<TElement, TDel>& obj, pointer_utils::PolyAllocWithTypeId alloc,
+                                               const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    auto ptr = obj.release();
+                    handler->destroy(alloc, ptr);
+                }
+
+                static void destroy(std::shared_ptr<TElement>& obj, MemResourceBase*, size_t) {
                     obj.reset();
                 }
 
-                static void assign(T &obj, TElement *valuePtr) {
-                    obj.reset(valuePtr);
+                static void destroyPolymorphic(std::shared_ptr<TElement>& obj, MemResourceBase*,
+                                               const std::shared_ptr<PolymorphicHandlerBase>&) {
+                    obj.reset();
                 }
 
-                //this is used, when old object exists and is the same type
-                static std::unique_ptr<pointer_utils::PointerSharedStateBase> saveToSharedState(T &obj) {
-                    auto state = new SharedPtrSharedState{};
-                    //to work with weak_ptr and shared_ptr create new std::shared_ptr
-                    state->obj = std::shared_ptr<TElement>(obj);
-                    return std::unique_ptr<pointer_utils::PointerSharedStateBase>{state};
+                static void destroy(std::weak_ptr<TElement>& obj, MemResourceBase*, size_t) {
+                    obj.reset();
                 }
 
-                //this is used, when old object doesn't exists or is not the same type
-                static std::unique_ptr<pointer_utils::PointerSharedStateBase> createSharedState(TElement *valuePtr) {
-                    auto state = new SharedPtrSharedState{};
-                    state->obj = std::shared_ptr<TElement>(valuePtr);
-                    return std::unique_ptr<pointer_utils::PointerSharedStateBase>{state};
+                static void destroyPolymorphic(std::weak_ptr<TElement>& obj, MemResourceBase*,
+                                               const std::shared_ptr<PolymorphicHandlerBase>&) {
+                    obj.reset();
                 }
 
-                static void loadFromSharedState(pointer_utils::PointerSharedStateBase *ctx, T &obj) {
-                    auto state = dynamic_cast<SharedPtrSharedState *>(ctx);
+                // define a type that will store shared state for shared and weak ptrs
+                using TSharedState = SharedPtrSharedState;
+
+                static void createShared(TSharedState& state,
+                    std::shared_ptr<TElement>& obj, MemResourceBase* memResource, size_t typeId) {
+                    // capture deleter parameters by value
+                    pointer_utils::PolyAllocWithTypeId alloc{memResource};
+                    obj.reset(alloc.newObject<TElement>(typeId), [alloc, typeId](TElement* data) {
+                            alloc.deleteObject(data, typeId);
+                        }, pointer_utils::StdPolyAlloc<TElement>(memResource));
+                    state.obj = obj;
+                }
+
+                static void createSharedPolymorphic(TSharedState& state,
+                    std::shared_ptr<TElement>& obj, MemResourceBase* memResource,
+                    const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    // capture deleter parameters by value
+                    pointer_utils::PolyAllocWithTypeId alloc{memResource};
+                    obj.reset(static_cast<TElement*>(handler->create(alloc)), [alloc, handler](TElement* data) {
+                            handler->destroy(alloc, data);
+                        }, pointer_utils::StdPolyAlloc<TElement>(memResource));
+                    state.obj = obj;
+                }
+
+                static void createShared(TSharedState& state,
+                    std::weak_ptr<TElement>& obj, MemResourceBase* memResource, size_t typeId) {
+                    pointer_utils::PolyAllocWithTypeId alloc{memResource};
+                    std::shared_ptr<TElement> res(alloc.newObject<TElement>(typeId),[alloc, typeId](TElement* data) {
+                            alloc.deleteObject(data, typeId);
+                        }, pointer_utils::StdPolyAlloc<TElement>(memResource));
+                    obj = res;
+                    state.obj = res;
+                }
+
+                static void createSharedPolymorphic(TSharedState& state,
+                    std::weak_ptr<TElement>& obj, MemResourceBase* memResource,
+                    const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                    pointer_utils::PolyAllocWithTypeId alloc{memResource};
+                    std::shared_ptr<TElement> res(static_cast<TElement*>(handler->create(alloc)),
+                        [alloc, handler](TElement* data) {
+                            handler->destroy(alloc, data);
+                        }, pointer_utils::StdPolyAlloc<TElement>(memResource));
+                    obj = res;
+                    state.obj = res;
+                }
+
+                static void saveToSharedState(TSharedState& state, T& obj) {
+                    state.obj = std::shared_ptr<TElement>(obj);
+                }
+
+                static void loadFromSharedState(TSharedState& state, T& obj) {
                     //reinterpret_pointer_cast is only since c++17
-                    auto p = reinterpret_cast<TElement *>(state->obj.get());
-                    obj = std::shared_ptr<TElement>(state->obj, p);
+                    auto p = reinterpret_cast<TElement*>(state.obj.get());
+                    obj = std::shared_ptr<TElement>(state.obj, p);
                 }
 
             };
@@ -103,7 +173,7 @@ namespace bitsery {
 
         template<typename RTTI>
         using StdSmartPtrBase = pointer_utils::PointerObjectExtensionBase<
-                smart_ptr_details::SmartPtrOwnerManager, PolymorphicContext, RTTI>;
+            smart_ptr_details::SmartPtrOwnerManager, PolymorphicContext, RTTI>;
 
         //helper type for convienience
         using StdSmartPtr = StdSmartPtrBase<StandardRTTI>;

include/bitsery/ext/std_stack.h

@@ -53,13 +53,13 @@ namespace bitsery {
         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 {
+            template<typename Ser, typename T, typename C, typename Fnc>
+            void serialize(Ser &ser, 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 {
+            template<typename Des, typename T, typename C, typename Fnc>
+            void deserialize(Des &des, std::stack<T,C> &obj, Fnc &&fnc) const {
                 des.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 

include/bitsery/ext/std_tuple.h

@@ -0,0 +1,81 @@
+//MIT License
+//
+//Copyright (c) 2019 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_TUPLE_H
+#define BITSERY_EXT_STD_TUPLE_H
+
+
+#include "utils/composite_type_overloads.h"
+#include "../traits/core/traits.h"
+#include <tuple>
+
+namespace bitsery {
+    namespace ext {
+
+        template<typename ...Overloads>
+        class StdTuple : public details::CompositeTypeOverloadsUtils<std::tuple, Overloads...> {
+        public:
+
+            template<typename Ser, typename Fnc, typename ...Ts>
+            void serialize(Ser& ser, const std::tuple<Ts...>& obj, Fnc&&) const {
+                serializeAll(ser, const_cast<std::tuple<Ts...>&>(obj));
+            }
+
+            template<typename Des, typename Fnc, typename ...Ts>
+            void deserialize(Des& des, std::tuple<Ts...>& obj, Fnc&&) const {
+                serializeAll(des, obj);
+            }
+
+        private:
+            template<typename S, typename ...Ts>
+            void serializeAll(S& s, std::tuple<Ts...>& obj) const {
+                this->execAll(obj, [this, &s](auto& data, auto index) {
+                    constexpr size_t Index = decltype(index)::value;
+                    this->serializeType(s, std::get<Index>(data));
+                });
+            }
+        };
+
+        // deduction guide
+        template<typename ...Overloads>
+        StdTuple(Overloads...) -> StdTuple<Overloads...>;
+    }
+
+    namespace traits {
+
+        template<typename Tuple, typename ... Overloads>
+        struct ExtensionTraits<ext::StdTuple<Overloads...>, Tuple> {
+            static_assert(bitsery::details::IsSpecializationOf<Tuple, std::tuple>::value,
+                          "StdTuple only works with std::tuple");
+            using TValue = void;
+            static constexpr bool SupportValueOverload = false;
+            static constexpr bool SupportObjectOverload = true;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+    }
+
+}
+
+
+#endif //BITSERY_EXT_STD_TUPLE_H

include/bitsery/ext/std_variant.h

@@ -0,0 +1,91 @@
+//MIT License
+//
+//Copyright (c) 2019 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_VARIANT_H
+#define BITSERY_EXT_STD_VARIANT_H
+
+
+#include "utils/composite_type_overloads.h"
+#include "../traits/core/traits.h"
+#include <variant>
+
+namespace bitsery {
+    namespace ext {
+
+        template<typename ...Overloads>
+        class StdVariant : public details::CompositeTypeOverloadsUtils<std::variant, Overloads...> {
+        public:
+
+            template<typename Ser, typename Fnc, typename ...Ts>
+            void serialize(Ser& ser, const std::variant<Ts...>& obj, Fnc&&) const {
+                auto index = obj.index();
+                assert(index != std::variant_npos);
+                details::writeSize(ser.adapter(), index);
+                this->execIndex(index, const_cast<std::variant<Ts...>&>(obj), [this, &ser](auto& data, auto index) {
+                    constexpr size_t Index = decltype(index)::value;
+                    this->serializeType(ser, std::get<Index>(data));
+                });
+            }
+
+            template<typename Des, typename Fnc, typename ...Ts>
+            void deserialize(Des& des, std::variant<Ts...>& obj, Fnc&&) const {
+                size_t index{};
+                details::readSize(des.adapter(), index, sizeof...(Ts), std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
+                this->execIndex(index, obj, [this, &des](auto& data, auto index) {
+                    constexpr size_t Index = decltype(index)::value;
+                    using TElem = typename std::variant_alternative<Index, std::variant<Ts...>>::type;
+                    TElem item = ::bitsery::Access::create<TElem>();
+                    this->serializeType(des, item);
+                    data = std::variant<Ts...>(std::in_place_index_t<Index>{}, std::move(item));
+                });
+            }
+
+        };
+
+        // deduction guide
+        template<typename ...Overloads>
+        StdVariant(Overloads...) -> StdVariant<Overloads...>;
+    }
+
+    //defines empty fuction, that handles monostate
+    template <typename S>
+    void serialize(S& , std::monostate&) {}
+
+    namespace traits {
+
+        template<typename Variant, typename ... Overloads>
+        struct ExtensionTraits<ext::StdVariant<Overloads...>, Variant> {
+            static_assert(bitsery::details::IsSpecializationOf<Variant, std::variant>::value,
+                          "StdVariant only works with std::variant");
+            using TValue = void;
+            static constexpr bool SupportValueOverload = false;
+            static constexpr bool SupportObjectOverload = true;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+    }
+
+}
+
+
+#endif //BITSERY_EXT_STD_VARIANT_H

include/bitsery/ext/utils/composite_type_overloads.h

@@ -0,0 +1,136 @@
+//MIT License
+//
+//Copyright (c) 2019 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_COMPOSITE_TYPE_OVERLOADS_H
+#define BITSERY_EXT_COMPOSITE_TYPE_OVERLOADS_H
+
+#include "../../details/serialization_common.h"
+#include <functional>
+
+#if __cplusplus < 201703L
+#error these utils requires c++17
+// in theory, it could be implemented using C++11
+// but without class template argument deduction guides that would be very inconvenient to use
+// these are very helpul for sum types (e.g. std::variant),
+// but for product types (e.g. std::tuple) you can you can easily do it your self with lambda, without extension
+#endif
+
+namespace bitsery {
+
+    namespace ext {
+        // might be usable, when you want to have one overload set for different composite types,
+        // e.g. variant, tuple and pair
+        template<class... Ts>
+        struct CompositeTypeOverloads : Ts ... {
+            using Ts::operator()...;
+        };
+
+        template<typename ...Overloads>
+        CompositeTypeOverloads(Overloads...) -> CompositeTypeOverloads<Overloads...>;
+
+        // convenient way to invoke s.value<N>, shorter than specifying a lambda
+        template<typename T, size_t N>
+        struct OverloadValue {
+            template <typename S>
+            void operator()(S& s, T& v) const {
+                s.template value<N>(v);
+            }
+        };
+
+        // convenient way to invoke other extension using value or object overloads
+        // there is no reason to write OverloadExtLambda,
+        // because you'll need to specify lambda type, which is very inconvenient and it will be much
+        // easier to simple write a lambda with extension inside it,
+        // in order to implement it in a convenient way, i need a way to deduce only last template parameter (lambda type)
+        // but this is not possible with deduction guides at the moment
+
+        template<typename T, size_t N, typename Ext>
+        struct OverloadExtValue : public Ext {
+            template <typename S>
+            void operator()(S& s, T& v) const {
+                s.template ext<N>(v, static_cast<const Ext&>(*this));
+            }
+        };
+
+        template<typename T, typename Ext>
+        struct OverloadExtObject : public Ext {
+            template <typename S>
+            void operator()(S& s, T& v) const {
+                s.ext(v, static_cast<const Ext&>(*this));
+            }
+        };
+    }
+
+    namespace details {
+
+        template<template<typename ...> typename CompositeType, typename ...Overloads>
+        class CompositeTypeOverloadsUtils : public ext::CompositeTypeOverloads<Overloads...> {
+        protected:
+            // converts run-time index to compile-time index,
+            // by calling lambda with std::integral_constant<size_t, INDEX>
+            template<typename Fnc, typename ... Ts>
+            void execIndex(size_t index, CompositeType<Ts...>& obj, Fnc&& fnc) const {
+                execIndexImpl(index, obj, std::forward<Fnc>(fnc), std::index_sequence_for<Ts...>{});
+            }
+
+            // call lambda for all indexes in composite type
+            template<typename Fnc, typename ... Ts>
+            void execAll(CompositeType<Ts...>& obj, Fnc&& fnc) const {
+                execAllImpl(obj, std::forward<Fnc>(fnc), std::index_sequence_for<Ts...>{});
+            }
+
+            // serialize a type, by using overload first
+            template<typename S, typename T>
+            void serializeType(S& s, T& v) const {
+                // first check if overload exists, otherwise try to call serialize method
+                if constexpr (hasOverload<S, T>()) {
+                    std::invoke(*this, s, v);
+                } else {
+                    static_assert(details::SerializeFunction<S, T>::isDefined(),
+                                  "Please define overload or 'serialize' function for your type.");
+                    s.object(v);
+                }
+            }
+
+        private:
+
+            template<typename S, typename T>
+            static constexpr bool hasOverload() {
+                return std::is_invocable<ext::CompositeTypeOverloads<Overloads...>,
+                    std::add_lvalue_reference_t<S>, std::add_lvalue_reference_t<T>>::value;
+            }
+
+            template<typename Variant, typename Fnc, size_t ...Is>
+            void execIndexImpl(size_t index, Variant& obj, Fnc&& fnc, std::index_sequence<Is...>) const {
+                ((index == Is ? fnc(obj, std::integral_constant<size_t, Is>{}), 0 : 0), ...);
+            }
+
+            template<typename Variant, typename Fnc, size_t ...Is>
+            void execAllImpl(Variant& obj, Fnc&& fnc, std::index_sequence<Is...>) const {
+                (fnc(obj, std::integral_constant<size_t, Is>{}), ...);
+            }
+        };
+
+    }
+}
+
+#endif //BITSERY_EXT_COMPOSITE_TYPE_OVERLOADS_H

include/bitsery/ext/utils/memory_resource.h

@@ -0,0 +1,171 @@
+//MIT License
+//
+//Copyright (c) 2018 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_MEMORY_RESOURCE_H
+#define BITSERY_EXT_MEMORY_RESOURCE_H
+
+#include "../../details/serialization_common.h"
+#include <new>
+
+namespace bitsery {
+    namespace ext {
+        // these are very similar to c++17 polymorphic allocator and memory resource classes
+        // but i don't want to enforce users to use c++17 if they want to use pointers
+        // plus this has additional information from RTTI about runtime type information,
+        // might be useful working with polymorphic types.
+        // The same memory resource is used to allocate internal data in various contexts,
+        // (typeId is always 0 for internal data allocation in contexts).
+
+        class MemResourceBase {
+        public:
+            virtual void* allocate(size_t bytes, size_t alignment, size_t typeId) = 0;
+
+            virtual void deallocate(void* ptr, size_t bytes, size_t alignment, size_t typeId) noexcept = 0;
+
+            virtual ~MemResourceBase() noexcept = default;
+        };
+
+        // default implementation for MemResourceBase using new and delete
+        class MemResourceNewDelete : public MemResourceBase {
+        public:
+            inline void* allocate(size_t bytes, size_t /*alignment*/, size_t /*typeId*/) final {
+                return (::operator new(bytes));
+            }
+
+            inline void
+            deallocate(void* ptr, size_t /*bytes*/, size_t /*alignment*/, size_t /*typeId*/) noexcept final {
+                (::operator delete(ptr));
+            }
+
+            ~MemResourceNewDelete() noexcept final = default;
+        };
+
+        // these classes are used internally by bitsery extensions and and pointer utils
+        namespace pointer_utils {
+            // this is helper class that stores memory resource and knows how to construct/destroy objects
+            // capture this by value for custom deleters, because during deserialization mem resource can be changed
+            class PolyAllocWithTypeId final {
+            public:
+
+                constexpr PolyAllocWithTypeId(MemResourceBase* memResource = nullptr)
+                :_resource{memResource} {}
+
+                template<typename T>
+                T* allocate(size_t n, size_t typeId) const {
+                    const auto bytes = sizeof(T) * n;
+                    constexpr auto alignment = std::alignment_of<T>::value;
+                    void* ptr = _resource
+                                ? _resource->allocate(bytes, alignment, typeId)
+                                : ext::MemResourceNewDelete{}.allocate(bytes, alignment, typeId);
+                    return static_cast<T*>(ptr);
+                }
+
+                template<typename T>
+                void deallocate(T* ptr, size_t n, size_t typeId) const noexcept {
+                    const auto bytes = sizeof(T) * n;
+                    constexpr auto alignment = std::alignment_of<T>::value;
+                    _resource
+                    ? _resource->deallocate(ptr, bytes, alignment, typeId)
+                    : ext::MemResourceNewDelete{}.deallocate(ptr, bytes, alignment, typeId);
+                }
+
+                template<typename T>
+                T* newObject(size_t typeId) const {
+                    auto ptr = allocate<T>(1, typeId);
+                    return ::bitsery::Access::create<T>(ptr);
+                }
+
+                template<typename T>
+                void deleteObject(T* obj, size_t typeId) const {
+                    obj->~T();
+                    deallocate(obj, 1, typeId);
+                }
+
+                void setMemResource(ext::MemResourceBase* resource) {
+                    _resource = resource;
+                }
+
+                ext::MemResourceBase* getMemResource() const {
+                    return _resource;
+                }
+
+                bool operator==(const PolyAllocWithTypeId& rhs) const noexcept {
+                    return _resource == rhs._resource;
+                }
+
+                bool operator!=(const PolyAllocWithTypeId& rhs) const noexcept {
+                    return !(*this == rhs);
+                }
+
+            private:
+                ext::MemResourceBase* _resource;
+            };
+
+            // this is very similar to c++17 PolymorphicAllocator
+            // it just wraps our PolyAllocWithTypeId and pass 0 as typeId
+            // and defines core functions for c++ Allocator concept,
+            template<class T>
+            class StdPolyAlloc {
+            public:
+                using value_type = T;
+
+                explicit constexpr StdPolyAlloc(MemResourceBase* memResource)
+                    :_alloc{memResource} {}
+                explicit constexpr StdPolyAlloc(PolyAllocWithTypeId alloc) : _alloc{alloc} {}
+
+                template <typename U>
+                friend class StdPolyAlloc;
+
+                template<class U>
+                constexpr explicit StdPolyAlloc(const StdPolyAlloc<U>& other) noexcept
+                    :_alloc{other._alloc} {
+                }
+
+                T* allocate(std::size_t n) {
+                    return _alloc.allocate<T>(n, 0);
+                }
+
+                void deallocate(T* p, std::size_t n) noexcept {
+                    return _alloc.deallocate(p, n, 0);
+                }
+
+                template<class U>
+                friend bool operator==(const StdPolyAlloc<T>& lhs,
+                                       const StdPolyAlloc<U>& rhs) noexcept {
+                    return lhs._alloc == rhs._alloc;
+                }
+
+                template<class U>
+                friend bool operator!=(const StdPolyAlloc<T>& lhs,
+                                       const StdPolyAlloc<U>& rhs) noexcept {
+                    return !(lhs == rhs);
+                }
+
+            private:
+                PolyAllocWithTypeId _alloc;
+            };
+
+        }
+    }
+
+}
+#endif //BITSERY_EXT_MEMORY_RESOURCE_H

include/bitsery/ext/utils/pointer_utils.h

@@ -28,13 +28,15 @@
 #include <memory>
 #include <algorithm>
 #include <cassert>
-#include "../../details/adapter_utils.h"
+#include "polymorphism_utils.h"
+#include "../../details/adapter_common.h"
+#include "../../details/serialization_common.h"
 
 namespace bitsery {
     namespace ext {
 
         //change name
-        enum class PointerType {
+        enum class PointerType : uint8_t {
             Nullable,
             NotNull
         };
@@ -53,9 +55,6 @@ namespace bitsery {
             SharedObserver
         };
 
-        //forward declaration
-        class PointerLinkingContext;
-
         namespace pointer_utils {
 
             //this class is used to store context for shared ptr owners
@@ -63,11 +62,23 @@ namespace bitsery {
                 virtual ~PointerSharedStateBase() = default;
             };
 
+            struct PointerSharedStateDeleter {
+                PointerSharedStateDeleter() = default;
+                explicit PointerSharedStateDeleter(MemResourceBase* memResource)
+                    :_memResource{memResource} {}
+                void operator()(PointerSharedStateBase* data) const {
+                    data->~PointerSharedStateBase();
+                    StdPolyAlloc<PointerSharedStateBase> alloc{_memResource};
+                    alloc.deallocate(data, 1);
+                }
+                MemResourceBase* _memResource;
+            };
+
             //PLC info is internal classes for serializer, and deserializer
             struct PLCInfo {
                 explicit PLCInfo(PointerOwnershipType ownershipType_)
-                        : ownershipType{ownershipType_},
-                          isSharedProcessed{false} {};
+                    : ownershipType{ownershipType_},
+                      isSharedProcessed{false} {};
                 PointerOwnershipType ownershipType;
                 bool isSharedProcessed;
 
@@ -81,7 +92,8 @@ namespace bitsery {
                         return;
                     }
                     //only shared ownership can get here multiple times
-                    assert(ptrType == PointerOwnershipType::SharedOwner || ptrType == PointerOwnershipType::SharedObserver);
+                    assert(ptrType == PointerOwnershipType::SharedOwner ||
+                           ptrType == PointerOwnershipType::SharedObserver);
                     //check if need to update to SharedOwner
                     if (ptrType == PointerOwnershipType::SharedOwner)
                         ownershipType = ptrType;
@@ -90,33 +102,39 @@ namespace bitsery {
                 }
             };
 
-            struct PLCInfoSerializer: PLCInfo {
+            struct PLCInfoSerializer : PLCInfo {
                 PLCInfoSerializer(size_t id_, PointerOwnershipType ownershipType_)
-                        : PLCInfo(ownershipType_), id{id_} {}
+                    : PLCInfo(ownershipType_), id{id_} {}
+
                 size_t id;
             };
 
             struct PLCInfoDeserializer : PLCInfo {
-                PLCInfoDeserializer(void *ptr, PointerOwnershipType ownershipType_)
-                        : PLCInfo(ownershipType_),
-                          ownerPtr{ptr} {};
+                PLCInfoDeserializer(void* ptr, PointerOwnershipType ownershipType_, MemResourceBase* memResource_)
+                    : PLCInfo(ownershipType_),
+                      ownerPtr{ptr},
+                      memResource{memResource_},
+                      observersList{StdPolyAlloc<std::reference_wrapper<void*>>{memResource_}} {};
 
                 //need to override these explicitly because we have pointer member
                 PLCInfoDeserializer(const PLCInfoDeserializer&) = delete;
-                PLCInfoDeserializer(PLCInfoDeserializer&&) = default;
-                PLCInfoDeserializer& operator =(const PLCInfoDeserializer&) = delete;
-                PLCInfoDeserializer& operator =(PLCInfoDeserializer&&) = default;
 
-                void processOwner(void *ptr) {
+                PLCInfoDeserializer(PLCInfoDeserializer&&) = default;
+
+                PLCInfoDeserializer& operator=(const PLCInfoDeserializer&) = delete;
+
+                PLCInfoDeserializer& operator=(PLCInfoDeserializer&&) = default;
+
+                void processOwner(void* ptr) {
                     ownerPtr = ptr;
                     assert(ownershipType != PointerOwnershipType::Observer);
-                    for (auto &o:observersList)
+                    for (auto& o:observersList)
                         o.get() = ptr;
                     observersList.clear();
                     observersList.shrink_to_fit();
                 }
 
-                void processObserver(void *(&ptr)) {
+                void processObserver(void* (& ptr)) {
                     if (ownerPtr) {
                         ptr = ownerPtr;
                     } else {
@@ -124,30 +142,32 @@ namespace bitsery {
                     }
                 }
 
-                void *ownerPtr;
-                std::vector<std::reference_wrapper<void *>> observersList{};
-                std::unique_ptr<PointerSharedStateBase> sharedState{};
+                void* ownerPtr;
+                MemResourceBase* memResource;
+                std::vector<std::reference_wrapper<void*>,
+                    StdPolyAlloc<std::reference_wrapper<void*>>> observersList;
+                std::unique_ptr<PointerSharedStateBase, PointerSharedStateDeleter> sharedState{};
             };
 
             class PointerLinkingContextSerialization {
             public:
-                explicit PointerLinkingContextSerialization()
-                        : _currId{0},
-                          _ptrMap{} {}
+                explicit PointerLinkingContextSerialization(MemResourceBase* memResource = nullptr)
+                    : _currId{0},
+                      _ptrMap{StdPolyAlloc<std::pair<const void* const, PLCInfoSerializer>>{memResource}} {}
 
-                PointerLinkingContextSerialization(const PointerLinkingContextSerialization &) = delete;
+                PointerLinkingContextSerialization(const PointerLinkingContextSerialization&) = delete;
 
-                PointerLinkingContextSerialization &operator=(const PointerLinkingContextSerialization &) = delete;
+                PointerLinkingContextSerialization& operator=(const PointerLinkingContextSerialization&) = delete;
 
-                PointerLinkingContextSerialization(PointerLinkingContextSerialization &&) = default;
+                PointerLinkingContextSerialization(PointerLinkingContextSerialization&&) = default;
 
-                PointerLinkingContextSerialization &operator=(PointerLinkingContextSerialization &&) = default;
+                PointerLinkingContextSerialization& operator=(PointerLinkingContextSerialization&&) = default;
 
                 ~PointerLinkingContextSerialization() = default;
 
-                const PLCInfoSerializer &getInfoByPtr(const void *ptr, PointerOwnershipType ptrType) {
+                const PLCInfoSerializer& getInfoByPtr(const void* ptr, PointerOwnershipType ptrType) {
                     auto res = _ptrMap.emplace(ptr, PLCInfoSerializer{_currId + 1u, ptrType});
-                    auto &ptrInfo = res.first->second;
+                    auto& ptrInfo = res.first->second;
                     if (res.second) {
                         ++_currId;
                         return ptrInfo;
@@ -160,7 +180,7 @@ namespace bitsery {
                 //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 *, PLCInfoSerializer> &p) {
+                                       [](const std::pair<const void*, PLCInfoSerializer>& p) {
                                            return p.second.ownershipType == PointerOwnershipType::SharedOwner ||
                                                   p.second.ownershipType == PointerOwnershipType::Owner;
                                        });
@@ -168,217 +188,299 @@ namespace bitsery {
 
             private:
                 size_t _currId;
-                std::unordered_map<const void *, PLCInfoSerializer> _ptrMap;
-
+                std::unordered_map<const void*, PLCInfoSerializer,
+                    std::hash<const void*>, std::equal_to<const void*>,
+                    StdPolyAlloc<std::pair<const void* const, PLCInfoSerializer>>
+                > _ptrMap;
             };
 
             class PointerLinkingContextDeserialization {
             public:
-                explicit PointerLinkingContextDeserialization()
-                        : _idMap{} {}
+                explicit PointerLinkingContextDeserialization(MemResourceBase* memResource = nullptr)
+                    : _memResource{memResource},
+                    _idMap{StdPolyAlloc<std::pair<const size_t, PLCInfoDeserializer>>{memResource}} {}
 
-                PointerLinkingContextDeserialization(const PointerLinkingContextDeserialization &) = delete;
+                PointerLinkingContextDeserialization(const PointerLinkingContextDeserialization&) = delete;
 
-                PointerLinkingContextDeserialization &operator=(const PointerLinkingContextDeserialization &) = delete;
+                PointerLinkingContextDeserialization& operator=(const PointerLinkingContextDeserialization&) = delete;
 
-                PointerLinkingContextDeserialization(PointerLinkingContextDeserialization &&) = default;
+                PointerLinkingContextDeserialization(PointerLinkingContextDeserialization&&) = default;
 
-                PointerLinkingContextDeserialization &operator=(PointerLinkingContextDeserialization &&) = default;
+                PointerLinkingContextDeserialization& operator=(PointerLinkingContextDeserialization&&) = default;
 
                 ~PointerLinkingContextDeserialization() = default;
 
-                PLCInfoDeserializer &getInfoById(size_t id, PointerOwnershipType ptrType) {
-                    auto res = _idMap.emplace(id, PLCInfoDeserializer{nullptr, ptrType});
-                    auto &ptrInfo = res.first->second;
+                PLCInfoDeserializer& getInfoById(size_t id, PointerOwnershipType ptrType) {
+                    auto res = _idMap.emplace(id, PLCInfoDeserializer{nullptr, ptrType, _memResource});
+                    auto& ptrInfo = res.first->second;
                     if (!res.second)
                         ptrInfo.update(ptrType);
                     return ptrInfo;
                 }
 
                 void clearSharedState() {
-                    for (auto &item: _idMap)
+                    for (auto& item: _idMap)
                         item.second.sharedState.reset();
                 }
 
                 //valid, when all pointers has owners
                 bool isPointerDeserializationValid() const {
                     return std::all_of(_idMap.begin(), _idMap.end(),
-                                       [](const std::pair<const size_t, PLCInfoDeserializer> &p) {
+                                       [](const std::pair<const size_t, PLCInfoDeserializer>& p) {
                                            return p.second.ownershipType == PointerOwnershipType::SharedOwner ||
                                                   p.second.ownershipType == PointerOwnershipType::Owner;
                                        });
                 }
 
+                MemResourceBase* getMemResource() noexcept {
+                    return _memResource;
+                }
+
+                void setMemResource(MemResourceBase* resource) noexcept {
+                    _memResource = resource;
+                }
+
             private:
-                std::unordered_map<size_t, PLCInfoDeserializer> _idMap;
+                MemResourceBase* _memResource;
+                std::unordered_map<size_t, PLCInfoDeserializer,
+                    std::hash<size_t>, std::equal_to<size_t>,
+                    StdPolyAlloc<std::pair<const size_t, PLCInfoDeserializer>>> _idMap;
             };
+        }
+
+        //this class is for convenience
+        class PointerLinkingContext :
+            public pointer_utils::PointerLinkingContextSerialization,
+            public pointer_utils::PointerLinkingContextDeserialization {
+        public:
+            explicit PointerLinkingContext(MemResourceBase* memResource = nullptr)
+            :pointer_utils::PointerLinkingContextSerialization(memResource),
+             pointer_utils::PointerLinkingContextDeserialization(memResource) {};
+
+            bool isValid() const {
+                return isPointerSerializationValid() && isPointerDeserializationValid();
+            }
+        };
+
+        namespace pointer_utils {
 
             template<template<typename> class TPtrManager,
-                    template<typename> class TPolymorphicContext, typename RTTI>
+                template<typename> class TPolymorphicContext, typename RTTI>
             class PointerObjectExtensionBase {
             public:
 
-                explicit PointerObjectExtensionBase(PointerType ptrType = PointerType::Nullable) :
-                        _ptrType{ptrType} {}
+                // helper types
+                template<typename T>
+                struct IsPolymorphic : std::integral_constant<bool,
+                    RTTI::template isPolymorphic<typename TPtrManager<T>::TElement>()> {
+                };
 
-                template<typename Ser, typename Writer, typename T, typename Fnc>
-                void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&fnc) const {
+                template<PointerOwnershipType Value>
+                using OwnershipType = std::integral_constant<PointerOwnershipType, Value>;
 
-                    auto ptr = TPtrManager<T>::getPtr(const_cast<T &>(obj));
+
+                explicit PointerObjectExtensionBase(PointerType ptrType = PointerType::Nullable,
+                                                    MemResourceBase* resource = nullptr,
+                                                    bool resourcePropagate = false) :
+                    _ptrType{ptrType},
+                    _resourcePropagate{resourcePropagate},
+                    _resource{resource} {
+                }
+
+                template<typename Ser, typename T, typename Fnc>
+                void serialize(Ser& ser, const T& obj, Fnc&& fnc) const {
+
+                    auto ptr = TPtrManager<T>::getPtr(const_cast<T&>(obj));
                     if (ptr) {
-                        auto ctx = ser.template context<PointerLinkingContext>();
-                        assert(ctx != nullptr);
-                        auto &ptrInfo = ctx->getInfoByPtr(getBasePtr(ptr), TPtrManager<T>::getOwnership());
-                        details::writeSize(w, ptrInfo.id);
+                        auto& ctx = ser.template context<pointer_utils::PointerLinkingContextSerialization>();
+                        auto& ptrInfo = ctx.getInfoByPtr(getBasePtr(ptr), TPtrManager<T>::getOwnership());
+                        details::writeSize(ser.adapter(), ptrInfo.id);
                         if (TPtrManager<T>::getOwnership() != PointerOwnershipType::Observer) {
                             if (!ptrInfo.isSharedProcessed)
-                                serializeImpl(ser, ptr, std::forward<Fnc>(fnc), w, IsPolymorphic<T>{});
+                                serializeImpl(ser, ptr, std::forward<Fnc>(fnc), IsPolymorphic<T>{});
                         }
                     } else {
                         assert(_ptrType == PointerType::Nullable);
-                        details::writeSize(w, 0);
+                        details::writeSize(ser.adapter(), 0);
                     }
 
                 }
 
-                template<typename Des, typename Reader, typename T, typename Fnc>
-                void deserialize(Des &des, Reader &r, T &obj, Fnc &&fnc) const {
+                template<typename Des, typename T, typename Fnc>
+                void deserialize(Des& des, T& obj, Fnc&& fnc) const {
                     size_t id{};
-                    details::readSize(r, id, std::numeric_limits<size_t>::max());
+                    details::readSize(des.adapter(), id, 0, std::false_type{});
+                    auto& ctx = des.template context<pointer_utils::PointerLinkingContextDeserialization>();
+                    auto prevResource = ctx.getMemResource();
+                    auto memResource = _resource ? _resource : prevResource;
+                    // if we have resource and propagate is true, then change current resource
+                    // so that deserializing nested pointers it will be used
+                    if (_resource && _resourcePropagate) {
+                        ctx.setMemResource(memResource);
+                    }
                     if (id) {
-                        auto ctx = des.template context<PointerLinkingContext>();
-                        assert(ctx != nullptr);
-                        auto &ptrInfo = ctx->getInfoById(id, TPtrManager<T>::getOwnership());
-                        deserializeImpl(ptrInfo, des, obj, std::forward<Fnc>(fnc), r, IsPolymorphic<T>{},
-                                        std::integral_constant<PointerOwnershipType, TPtrManager<T>::getOwnership()>{});
+                        auto& ptrInfo = ctx.getInfoById(id, TPtrManager<T>::getOwnership());
+                        deserializeImpl(memResource, ptrInfo, des, obj, std::forward<Fnc>(fnc), IsPolymorphic<T>{},
+                                        OwnershipType<TPtrManager<T>::getOwnership()>{});
                     } else {
                         if (_ptrType == PointerType::Nullable) {
-                            TPtrManager<T>::clear(obj);
+                            if (auto ptr = TPtrManager<T>::getPtr(obj)) {
+                                destroyPtr(memResource, des, obj, IsPolymorphic<T>{});
+                            };
                         } else
-                            r.setError(ReaderError::InvalidPointer);
+                            des.adapter().error(ReaderError::InvalidPointer);
+                    }
+                    if (_resource && _resourcePropagate) {
+                        ctx.setMemResource(prevResource);
                     }
                 }
 
             private:
 
-                template<typename T>
-                struct IsPolymorphic : std::integral_constant<bool,
-                        RTTI::template isPolymorphic<typename TPtrManager<T>::TElement>()> {
-                };
+                template<typename Des, typename TObj>
+                void destroyPtr(MemResourceBase* memResource, Des& des, TObj& obj,
+                                std::true_type /*polymorphic*/) const {
+                    const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
+                    auto ptr = TPtrManager<TObj>::getPtr(obj);
+                    TPtrManager<TObj>::destroyPolymorphic(obj, memResource, ctx.getPolymorphicHandler(*ptr));
+                }
+
+                template<typename Des, typename TObj>
+                void destroyPtr(MemResourceBase* memResource, Des&, TObj& obj,
+                                std::false_type /*polymorphic*/) const {
+                    TPtrManager<TObj>::destroy(obj, memResource, RTTI::template get<typename TPtrManager<TObj>::TElement>());
+                }
+
 
                 template<typename T>
-                const void *getBasePtr(const T *ptr) const {
+                const void* getBasePtr(const T* ptr) const {
                     // todo implement handling of types with virtual inheritance
                     // this is required to correctly track same object, when one object is derived and other is base class
                     // e.g. shared_ptr<Base> and weak_ptr<Derived> or pointer observer Base*
                     return ptr;
                 }
 
-                template<typename Ser, typename TPtr, typename Fnc, typename Writer>
-                void serializeImpl(Ser &ser, TPtr &ptr, Fnc &&, Writer &w, std::true_type) const {
-                    const auto &ctx = ser.template context<TPolymorphicContext<RTTI>>();
-                    ctx->serialize(ser, w, *ptr);
+                template<typename Ser, typename TPtr, typename Fnc>
+                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&&, std::true_type) const {
+                    const auto& ctx = ser.template context<TPolymorphicContext<RTTI>>();
+                    ctx.serialize(ser, *ptr);
                 }
 
-                template<typename Ser, typename TPtr, typename Fnc, typename Writer>
-                void serializeImpl(Ser &, TPtr &ptr, Fnc &&fnc, Writer &, std::false_type) const {
-                    fnc(*ptr);
+                template<typename Ser, typename TPtr, typename Fnc>
+                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&& fnc, std::false_type) const {
+                    fnc(ser, *ptr);
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &des, T &obj, Fnc &&,
-                                     Reader &r, std::true_type ,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::Owner>) const {
-                    const auto &ctx = des.template context<TPolymorphicContext<RTTI>>();
-                    ctx->deserialize(des, r, TPtrManager<T>::getPtr(obj),
-                                     [&obj, this](typename TPtrManager<T>::TElement *valuePtr) {
-                                         TPtrManager<T>::assign(obj, valuePtr);
+                template<typename Des, typename T, typename Fnc>
+                void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
+                                     std::true_type, OwnershipType<PointerOwnershipType::Owner>) const {
+                    const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
+                    ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
+                                     [&obj, this, memResource](
+                                         const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                                         TPtrManager<T>::createPolymorphic(obj, memResource, handler);
+                                         return TPtrManager<T>::getPtr(obj);
+                                     },
+                                     [&obj, memResource, this](const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                                         TPtrManager<T>::destroyPolymorphic(obj, memResource, handler);
                                      });
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &, T &obj, Fnc &&fnc,
-                                     Reader &, std::false_type ,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::Owner>) const {
+                template<typename Des, typename T, typename Fnc>
+                void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
+                                     std::false_type, OwnershipType<PointerOwnershipType::Owner>) const {
                     auto ptr = TPtrManager<T>::getPtr(obj);
                     if (ptr) {
-                        fnc(*ptr);
+                        fnc(des, *ptr);
                     } else {
-                        ptr = new typename TPtrManager<T>::TElement{};
-                        fnc(*ptr);
-                        TPtrManager<T>::assign(obj, ptr);
+                        TPtrManager<T>::create(obj, memResource, RTTI::template get<typename TPtrManager<T>::TElement>());
+                        ptr = TPtrManager<T>::getPtr(obj);
+                        fnc(des, *ptr);
                     }
                     ptrInfo.processOwner(ptr);
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &des, T &obj, Fnc &&,
-                                     Reader &r, std::true_type ,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::SharedOwner>) const {
-                    auto &sharedState = ptrInfo.sharedState;
-                    if (!sharedState) {
-                        const auto &ctx = des.template context<TPolymorphicContext<RTTI>>();
-                        ctx->deserialize(des, r, TPtrManager<T>::getPtr(obj),
-                                         [&obj, &sharedState](typename TPtrManager<T>::TElement *valuePtr) {
-                                             sharedState = TPtrManager<T>::createSharedState(valuePtr);
+                template<typename Des, typename T, typename Fnc>
+                void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
+                                     std::true_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
+                    if (!ptrInfo.sharedState) {
+                        const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
+                        ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
+                                         [&obj, &ptrInfo, memResource, this](
+                                             const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                                             TPtrManager<T>::createSharedPolymorphic(
+                                                 createAndGetSharedStateObj<T>(ptrInfo),
+                                                 obj, memResource, handler);
+                                             return TPtrManager<T>::getPtr(obj);
+                                         },
+                                         [&obj, memResource, this](const std::shared_ptr<PolymorphicHandlerBase>& handler) {
+                                             TPtrManager<T>::destroyPolymorphic(obj, memResource, handler);
                                          });
-                        if (!sharedState)
-                            sharedState = TPtrManager<T>::saveToSharedState(obj);
+                        if (!ptrInfo.sharedState)
+                            TPtrManager<T>::saveToSharedState(createAndGetSharedStateObj<T>(ptrInfo), obj);
                     }
-                    TPtrManager<T>::loadFromSharedState(sharedState.get(), obj);
+                    TPtrManager<T>::loadFromSharedState(getSharedStateObj<T>(ptrInfo), obj);
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &, T &obj, Fnc &&fnc,
-                                     Reader &, std::false_type ,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::SharedOwner>) const {
-                    auto &sharedState = ptrInfo.sharedState;
-                    if (!sharedState) {
-                        if (auto ptr = TPtrManager<T>::getPtr(obj)) {
-                            fnc(*ptr);
-                            sharedState = TPtrManager<T>::saveToSharedState(obj);
+                template<typename Des, typename T, typename Fnc>
+                void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
+                                     std::false_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
+                    if (!ptrInfo.sharedState) {
+                        auto ptr = TPtrManager<T>::getPtr(obj);
+                        if (ptr) {
+                            TPtrManager<T>::saveToSharedState(createAndGetSharedStateObj<T>(ptrInfo), obj);
                         } else {
-                            auto res = new typename TPtrManager<T>::TElement{};
-                            fnc(*res);
-                            sharedState = TPtrManager<T>::createSharedState(res);
+                            TPtrManager<T>::createShared(
+                                createAndGetSharedStateObj<T>(ptrInfo),
+                                obj, memResource, RTTI::template get<typename TPtrManager<T>::TElement>());
+                            ptr = TPtrManager<T>::getPtr(obj);
                         }
+                        fnc(des, *ptr);
                     }
-                    TPtrManager<T>::loadFromSharedState(sharedState.get(), obj);
+                    TPtrManager<T>::loadFromSharedState(getSharedStateObj<T>(ptrInfo), obj);
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorph>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &des, T &obj, Fnc &&fnc,
-                                     Reader &r, isPolymorph polymorph,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::SharedObserver>) const {
-                    deserializeImpl(ptrInfo, des, obj, fnc, r, polymorph,
-                                    std::integral_constant<PointerOwnershipType, PointerOwnershipType::SharedOwner>{});
+                template<typename Des, typename T, typename Fnc, typename isPolymorph>
+                void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj,
+                                     Fnc&& fnc, isPolymorph polymorph,
+                                     OwnershipType<PointerOwnershipType::SharedObserver>) const {
+                    deserializeImpl(memResource, ptrInfo, des, obj, fnc, polymorph,
+                                    OwnershipType<PointerOwnershipType::SharedOwner>{});
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorphic>
-                void deserializeImpl(PLCInfoDeserializer &ptrInfo, Des &, T &obj, Fnc &&,
-                                     Reader &, isPolymorphic,
-                                     std::integral_constant<PointerOwnershipType, PointerOwnershipType::Observer>) const {
-                    ptrInfo.processObserver(reinterpret_cast<void *&>(TPtrManager<T>::getPtrRef(obj)));
+                template<typename Des, typename T, typename Fnc, typename isPolymorphic>
+                void deserializeImpl(MemResourceBase* , PLCInfoDeserializer& ptrInfo, Des&, T& obj, Fnc&&,
+                                     isPolymorphic, OwnershipType<PointerOwnershipType::Observer>) const {
+                    ptrInfo.processObserver(reinterpret_cast<void*&>(TPtrManager<T>::getPtrRef(obj)));
                 }
 
+                template <typename T>
+                typename TPtrManager<T>::TSharedState& createAndGetSharedStateObj(PLCInfoDeserializer& info) const {
+                    using TSharedState = typename TPtrManager<T>::TSharedState;
+                    StdPolyAlloc<TSharedState> alloc {info.memResource};
+                    auto* ptr = alloc.allocate(1);
+                    auto* obj = new (ptr)TSharedState{};
+                    info.sharedState = std::unique_ptr<PointerSharedStateBase, PointerSharedStateDeleter>(
+                        obj, PointerSharedStateDeleter{info.memResource});
+                    return *obj;
+                }
+
+                template <typename T>
+                typename TPtrManager<T>::TSharedState& getSharedStateObj(PLCInfoDeserializer& info) const {
+                    return static_cast<typename TPtrManager<T>::TSharedState&>(*info.sharedState);
+                }
+
+
                 PointerType _ptrType;
+                bool _resourcePropagate;
+                MemResourceBase* _resource;
             };
 
         }
 
-        //this class is for convenience
-        class PointerLinkingContext :
-                public pointer_utils::PointerLinkingContextSerialization,
-                public pointer_utils::PointerLinkingContextDeserialization {
-        public:
-            bool isValid() {
-                return isPointerSerializationValid() && isPointerDeserializationValid();
-            }
-        };
-
     }
 }
 

include/bitsery/ext/utils/polymorphism_utils.h

@@ -25,7 +25,9 @@
 
 #include <unordered_map>
 #include <memory>
+#include "memory_resource.h"
 #include "../../details/adapter_common.h"
+#include "../../details/serialization_common.h"
 
 namespace bitsery {
 
@@ -59,8 +61,12 @@ namespace bitsery {
 
         class PolymorphicHandlerBase {
         public:
-            virtual void *create() const = 0;
-            virtual void process(void *ser, void *obj) const = 0;
+            virtual void* create(const pointer_utils::PolyAllocWithTypeId& alloc) const = 0;
+
+            virtual void destroy(const pointer_utils::PolyAllocWithTypeId& alloc, void* ptr) const = 0;
+
+            virtual void process(void* ser, void* obj) const = 0;
+
             virtual ~PolymorphicHandlerBase() = default;
         };
 
@@ -68,22 +74,26 @@ namespace bitsery {
         class PolymorphicHandler : public PolymorphicHandlerBase {
         public:
 
-            void *create() const final {
-                return toBase(new TDerived{});
+            void* create(const pointer_utils::PolyAllocWithTypeId& alloc) const final {
+                return toBase(alloc.newObject<TDerived>(RTTI::template get<TDerived>()));
             }
 
-            void process(void *ser, void *obj) const final {
-                static_cast<TSerializer *>(ser)->object(*static_cast<TDerived *>(fromBase(obj)));
+            void destroy(const pointer_utils::PolyAllocWithTypeId& alloc, void* ptr) const final {
+                alloc.deleteObject<TDerived>(fromBase(ptr), RTTI::template get<TDerived>());
+            }
+
+            void process(void* ser, void* obj) const final {
+                static_cast<TSerializer*>(ser)->object(*fromBase(obj));
             }
 
         private:
 
-            void *fromBase(void *obj) const {
-                return RTTI::template cast<TBase, TDerived>(static_cast<TBase *>(obj));
+            TDerived* fromBase(void* obj) const {
+                return RTTI::template cast<TBase, TDerived>(static_cast<TBase*>(obj));
             }
 
-            void *toBase(void *obj) const {
-                return RTTI::template cast<TDerived, TBase>(static_cast<TDerived *>(obj));
+            TBase* toBase(void* obj) const {
+                return RTTI::template cast<TDerived, TBase>(static_cast<TDerived*>(obj));
             }
 
         };
@@ -97,13 +107,13 @@ namespace bitsery {
                 std::size_t baseHash;
                 std::size_t derivedHash;
 
-                bool operator==(const BaseToDerivedKey &other) const {
+                bool operator==(const BaseToDerivedKey& other) const {
                     return baseHash == other.baseHash && derivedHash == other.derivedHash;
                 }
             };
 
             struct BaseToDerivedKeyHashier {
-                size_t operator()(const BaseToDerivedKey &key) const {
+                size_t operator()(const BaseToDerivedKey& key) const {
                     return (key.baseHash + (key.baseHash << 6) + (key.derivedHash >> 2)) ^ key.derivedHash;
                 }
             };
@@ -130,10 +140,26 @@ namespace bitsery {
 
             template<typename TSerializer, typename TBase, typename TDerived>
             void addToMap(std::false_type) {
+                using THandler = PolymorphicHandler<RTTI, TSerializer, TBase, TDerived>;
                 BaseToDerivedKey key{RTTI::template get<TBase>(), RTTI::template get<TDerived>()};
-                if (_baseToDerivedMap.emplace(key, std::unique_ptr<PolymorphicHandlerBase>(
-                        new PolymorphicHandler<RTTI, TSerializer, TBase, TDerived>{})).second)
-                    _baseToDerivedArray[key.baseHash].push_back(key.derivedHash);
+                pointer_utils::StdPolyAlloc<THandler> alloc{_memResource};
+                auto ptr = alloc.allocate(1);
+                std::shared_ptr<THandler> handler(new (ptr)THandler{}, [alloc](THandler* data) mutable {
+                        data->~THandler();
+                        alloc.deallocate(data, 1);
+                    }, alloc);
+                if (_baseToDerivedMap
+                    .emplace(key, std::move(handler))
+                    .second) {
+                    auto it = _baseToDerivedArray.find(key.baseHash);
+                    if (it == _baseToDerivedArray.end()) {
+                        it = _baseToDerivedArray.emplace(
+                            std::piecewise_construct,
+                            std::forward_as_tuple(key.baseHash),
+                            std::forward_as_tuple(pointer_utils::StdPolyAlloc<size_t>{_memResource})).first;
+                    }
+                    it->second.push_back(key.derivedHash);
+                }
             }
 
             template<typename TSerializer, typename TBase, typename TDerived>
@@ -141,29 +167,41 @@ namespace bitsery {
                 //cannot add abstract class
             }
 
-            std::unordered_map<BaseToDerivedKey, std::unique_ptr<PolymorphicHandlerBase>, BaseToDerivedKeyHashier> _baseToDerivedMap{};
+            MemResourceBase* _memResource;
+            // store shared ptr to polymorphic handler, because it might be copied to "smart pointer" deleter
+            std::unordered_map<BaseToDerivedKey, std::shared_ptr<PolymorphicHandlerBase>,
+                BaseToDerivedKeyHashier, std::equal_to<BaseToDerivedKey>,
+                    pointer_utils::StdPolyAlloc<std::pair<const BaseToDerivedKey, std::shared_ptr<PolymorphicHandlerBase>>>
+            > _baseToDerivedMap;
             // this will allow convert from platform specific type information, to platform independent base->derived index
             // this only works if all polymorphic relationships (PolymorphicBaseClass<TBase> -> PolymorphicDerivedClasses<TDerived...>)
             // is equal between platforms.
-            std::unordered_map<size_t, std::vector<size_t>> _baseToDerivedArray{};
+            std::unordered_map<size_t, std::vector<size_t, pointer_utils::StdPolyAlloc<size_t>>,
+                std::hash<size_t>, std::equal_to<size_t>,
+                pointer_utils::StdPolyAlloc<std::pair<const size_t, std::vector<size_t, pointer_utils::StdPolyAlloc<size_t>>>>
+                > _baseToDerivedArray;
 
         public:
 
+            explicit PolymorphicContext(MemResourceBase* memResource = nullptr)
+                :_memResource{memResource},
+                _baseToDerivedMap{pointer_utils::StdPolyAlloc<std::pair<const BaseToDerivedKey,
+                std::shared_ptr<PolymorphicHandlerBase>>>{memResource}},
+                 _baseToDerivedArray{pointer_utils::StdPolyAlloc<std::pair<const size_t,
+                     std::vector<size_t, pointer_utils::StdPolyAlloc<size_t>>>>{memResource}}
+            {}
+
+            PolymorphicContext(const PolymorphicContext& ) = delete;
+            PolymorphicContext& operator = (const PolymorphicContext&) = delete;
+            PolymorphicContext(PolymorphicContext&& ) = default;
+            PolymorphicContext& operator = (PolymorphicContext&&) = default;
+
+
             void clear() {
                 _baseToDerivedMap.clear();
                 _baseToDerivedArray.clear();
             }
 
-            template<typename TSerializer, template<typename> class THierarchy = PolymorphicBaseClass, typename T1, typename ...Tn>
-            [[deprecated("de/serializer instance is not required")]] void registerBasesList(const TSerializer &s, PolymorphicClassesList<T1, Tn...>) {
-                add<TSerializer, THierarchy, T1, T1>();
-                registerBasesList<TSerializer, THierarchy>(s, PolymorphicClassesList<Tn...>{});
-            }
-
-            template<typename TSerializer, template<typename> class THierarchy>
-            [[deprecated]] void registerBasesList(const TSerializer &, PolymorphicClassesList<>) {
-            }
-
             // THierarchy is the name of class, that defines hierarchy
             // PolymorphicBaseClass is defined as default parameter, so that at instantiation time
             // it will get unique symbol in translation unit for PolymorphicBaseClass (which is defined in anonymous namespace)
@@ -179,7 +217,7 @@ namespace bitsery {
             }
 
             // optional method, in case you want to construct base class hierarchy your self
-            template <typename TSerializer, typename TBase, typename TDerived>
+            template<typename TSerializer, typename TBase, typename TDerived>
             void registerSingleBaseBranch() {
                 static_assert(std::is_base_of<TBase, TDerived>::value, "TDerived must be derived from TBase");
                 static_assert(!std::is_abstract<TDerived>::value, "TDerived cannot be abstract");
@@ -187,27 +225,28 @@ namespace bitsery {
             }
 
 
-            template<typename Serializer, typename Writer, typename TBase>
-            void serialize(Serializer &ser, Writer &writer, TBase &obj) {
+            template<typename Serializer, typename TBase>
+            void serialize(Serializer& ser, TBase& obj) const {
                 //get derived key
                 BaseToDerivedKey key{RTTI::template get<TBase>(), RTTI::template get<TBase>(obj)};
                 auto it = _baseToDerivedMap.find(key);
                 assert(it != _baseToDerivedMap.end());
 
                 //convert derived hash to derived index, to make it work in cross-platform environment
-                auto &vec = _baseToDerivedArray.find(key.baseHash)->second;
+                auto& vec = _baseToDerivedArray.find(key.baseHash)->second;
                 auto derivedIndex = static_cast<size_t>(std::distance(vec.begin(), std::find(vec.begin(), vec.end(),
                                                                                              key.derivedHash)));
-                details::writeSize(writer, derivedIndex);
+                details::writeSize(ser.adapter(), derivedIndex);
 
                 //serialize
                 it->second->process(&ser, &obj);
             }
 
-            template<typename Deserializer, typename Reader, typename TBase, typename TAssignFnc>
-            void deserialize(Deserializer &des, Reader &reader, TBase *obj, TAssignFnc assignFnc) {
+            template<typename Deserializer, typename TBase, typename TCreateFnc, typename TDestroyFnc>
+            void deserialize(Deserializer& des, TBase* obj,
+                             TCreateFnc createFnc, TDestroyFnc destroyFnc) const {
                 size_t derivedIndex{};
-                details::readSize(reader, derivedIndex, std::numeric_limits<size_t>::max());
+                details::readSize(des.adapter(), derivedIndex, 0, std::false_type{});
 
                 auto baseToDerivedVecIt = _baseToDerivedArray.find(RTTI::template get<TBase>());
                 //base class is known at compile time, so we can assert on this one
@@ -216,18 +255,29 @@ namespace bitsery {
                 if (baseToDerivedVecIt->second.size() > derivedIndex) {
                     //convert derived index to derived hash, to make it work in cross-platform environment
                     auto derivedHash = baseToDerivedVecIt->second[derivedIndex];
-                    auto &handler = _baseToDerivedMap.find(
-                            BaseToDerivedKey{RTTI::template get<TBase>(), derivedHash})->second;
+                    auto& handler = _baseToDerivedMap.find(
+                        BaseToDerivedKey{RTTI::template get<TBase>(), derivedHash})->second;
                     //if object is null or different type, create new and assign it
                     if (obj == nullptr || RTTI::template get<TBase>(*obj) != derivedHash) {
-                        obj = static_cast<TBase *>(handler->create());
-                        assignFnc(obj);
+                        if (obj) {
+                            destroyFnc(getPolymorphicHandler(*obj));
+                        }
+                        obj = createFnc(handler);
                     }
                     handler->process(&des, obj);
                 } else
-                    reader.setError(ReaderError::InvalidPointer);
+                    des.adapter().error(ReaderError::InvalidPointer);
             }
 
+            template<typename TBase>
+            const std::shared_ptr<PolymorphicHandlerBase>& getPolymorphicHandler(TBase& obj) const {
+                auto deleteHandlerIt = _baseToDerivedMap.find(
+                    BaseToDerivedKey{RTTI::template get<TBase>(), RTTI::template get<TBase>(obj)});
+                assert(deleteHandlerIt != _baseToDerivedMap.end());
+                return deleteHandlerIt->second;
+            }
+
+
         };
 
     }

include/bitsery/ext/utils/rtti_utils.h

@@ -37,7 +37,7 @@ namespace bitsery {
 //                              !std::is_volatile<TBase>::value, "");
 
             template<typename TBase>
-            static size_t get(TBase &obj) {
+            static size_t get(TBase& obj) {
                 return typeid(obj).hash_code();
             }
 
@@ -47,9 +47,9 @@ namespace bitsery {
             }
 
             template<typename TBase, typename TDerived>
-            static constexpr TDerived *cast(TBase *obj) {
+            static constexpr TDerived* cast(TBase* obj) {
                 static_assert(!std::is_pointer<TDerived>::value, "");
-                return dynamic_cast<TDerived *>(obj);
+                return dynamic_cast<TDerived*>(obj);
             }
 
             template<typename TBase>

include/bitsery/ext/value_range.h

@@ -96,7 +96,8 @@ namespace bitsery {
             constexpr RangeSpec(T minValue, T maxValue, T precision) :
                     min{minValue},
                     max{maxValue},
-                    bitsRequired{calcRequiredBits<details::SameSizeUnsigned<T>>({}, ((max - min) / precision))} {
+                    bitsRequired{calcRequiredBits<details::SameSizeUnsigned<T>>(
+                            {}, static_cast<details::SameSizeUnsigned<T>>((max - min) / precision))} {
 
             }
 
@@ -163,29 +164,41 @@ namespace bitsery {
         public:
 
             template<typename ... Args>
-            explicit constexpr ValueRange(Args &&... args):_range{std::forward<Args>(args)...} {}
+            constexpr ValueRange(const TValue& min, const TValue& max, Args &&... args)
+                    :_range{min, max, std::forward<Args>(args)...} {}
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &v, Fnc &&) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, 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);
+                ser.adapter().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 {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &v, Fnc &&) const {
+                auto& reader = des.adapter();
                 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;
-                }
+                handleInvalidRange(reader, v, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
             }
 
             constexpr size_t getRequiredBits() const {
                 return _range.bitsRequired;
             };
         private:
+
+            template <typename Reader, typename T>
+            void handleInvalidRange(Reader& reader, T& v, std::true_type) const {
+                if (!details::isRangeValid(v, _range)) {
+                    reader.error(ReaderError::InvalidData);
+                    v = _range.min;
+                }
+            }
+
+            template <typename Reader, typename T>
+            void handleInvalidRange(Reader&, T&, std::false_type) const {
+            }
+
             details::RangeSpec<TValue> _range;
         };
     }

include/bitsery/serializer.h

@@ -25,89 +25,183 @@
 #define BITSERY_SERIALIZER_H
 
 #include "details/serialization_common.h"
-#include "adapter_writer.h"
+#include "details/adapter_common.h"
 #include <cassert>
 
 namespace bitsery {
 
-    template<typename TAdapterWriter, typename TContext = void>
-    class BasicSerializer {
+    namespace details {
+        template<typename TAdapter>
+        class OutputAdapterBitPackingWrapper {
+        public:
+
+            static constexpr bool BitPackingEnabled = true;
+            using TConfig = typename TAdapter::TConfig;
+            using TValue = typename TAdapter::TValue;
+
+            OutputAdapterBitPackingWrapper(TAdapter& adapter)
+                : _wrapped{adapter}
+            {
+            }
+
+
+            ~OutputAdapterBitPackingWrapper() {
+                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) {
+                    this->_wrapped.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) {
+                    this->_wrapped.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 currentWritePos(size_t pos) {
+                align();
+                this->_wrapped.currentWritePos(pos);
+            }
+
+            size_t currentWritePos() const {
+                return this->_wrapped.currentWritePos();
+            }
+
+            void flush() {
+                align();
+                this->_wrapped.flush();
+            }
+
+            size_t writtenBytesCount() const {
+                return this->_wrapped.writtenBytesCount();
+            }
+
+        private:
+            TAdapter& _wrapped;
+
+            using UnsignedType = typename std::make_unsigned<typename TAdapter::TValue>::type;
+            using ScratchType = typename details::ScratchType<UnsignedType>::type;
+            static_assert(details::IsDefined<ScratchType>::value, "Underlying adapter value type is not supported");
+
+
+            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);
+                        this->_wrapped.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);
+                        this->_wrapped.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{};
+        };
+
+    }
+
+    template<typename TOutputAdapter, typename TContext = void>
+    class Serializer: public details::AdapterAndContextRef<TOutputAdapter, TContext> {
     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>;
+        using BPEnabledType = Serializer<typename std::conditional<TOutputAdapter::BitPackingEnabled,
+                TOutputAdapter,
+                details::OutputAdapterBitPackingWrapper<TOutputAdapter>>::type, TContext>;
+        using TConfig = typename TOutputAdapter::TConfig;
 
-        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);
-        }
+        using details::AdapterAndContextRef<TOutputAdapter, TContext>::AdapterAndContextRef;
 
         /*
          * object function
          */
         template<typename T>
         void object(const T &obj) {
-            details::SerializeFunction<BasicSerializer, T>::invoke(*this, const_cast<T& >(obj));
+            details::SerializeFunction<Serializer, T>::invoke(*this, const_cast<T& >(obj));
         }
 
         template<typename T, typename Fnc>
         void object(const T &obj, Fnc &&fnc) {
-            fnc(const_cast<T& >(obj));
+            fnc(*this, const_cast<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<BasicSerializer, T>::invoke(*this, std::forward<T>(head));
-            //expand other elements
-            archive(std::forward<TArgs>(tail)...);
+
+        template <typename... TArgs>
+        Serializer &operator()(TArgs &&... args) {
+            archive(std::forward<TArgs>(args)...);
+            return *this;
         }
 
         /*
          * value overloads
          */
 
-        template<size_t VSIZE, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
+        template<size_t VSIZE, typename T>
         void value(const T &v) {
+            static_assert(details::IsFundamentalType<T>::value, "Value must be integral, float or enum type.");
             using TValue = typename details::IntegralFromFundamental<T>::TValue;
-            _writer.template writeBytes<VSIZE>(reinterpret_cast<const TValue &>(v));
+            this->_adapter.template writeBytes<VSIZE>(reinterpret_cast<const TValue &>(v));
         }
 
         /*
@@ -115,7 +209,9 @@ namespace bitsery {
          */
         template <typename Fnc>
         void enableBitPacking(Fnc&& fnc) {
-            procEnableBitPacking(std::forward<Fnc>(fnc), std::integral_constant<bool, TAdapterWriter::BitPackingEnabled>{});
+            procEnableBitPacking(std::forward<Fnc>(fnc),
+                std::integral_constant<bool, TOutputAdapter::BitPackingEnabled>{},
+                std::integral_constant<bool, Serializer::HasContext>{});
         }
 
         /*
@@ -127,7 +223,7 @@ namespace bitsery {
             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));
+            extension.serialize(*this, obj, std::forward<Fnc>(fnc));
         }
 
         template<size_t VSIZE, typename T, typename Ext>
@@ -137,7 +233,7 @@ namespace bitsery {
                           "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); });
+            extension.serialize(*this, obj, [](Serializer& s, VType &v) { s.value<VSIZE>(v); });
         }
 
         template<typename T, typename Ext>
@@ -147,7 +243,7 @@ namespace bitsery {
                           "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); });
+            extension.serialize(*this, obj, [](Serializer& s, VType &v) { s.object(v); });
         }
 
         /*
@@ -155,7 +251,7 @@ namespace bitsery {
          */
 
         void boolValue(bool v) {
-            procBoolValue(v, std::integral_constant<bool, TAdapterWriter::BitPackingEnabled>{});
+            procBoolValue(v, std::integral_constant<bool, TOutputAdapter::BitPackingEnabled>{});
         }
 
         /*
@@ -194,7 +290,7 @@ namespace bitsery {
                           "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);
+            details::writeSize(this->_adapter, size);
             procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
         }
 
@@ -207,7 +303,7 @@ namespace bitsery {
             static_assert(VSIZE > 0, "");
             auto size = traits::ContainerTraits<T>::size(obj);
             assert(size <= maxSize);
-            details::writeSize(_writer, size);
+            details::writeSize(this->_adapter, size);
 
             procContainer<VSIZE>(std::begin(obj), std::end(obj), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
         }
@@ -220,7 +316,7 @@ namespace bitsery {
                           "use container(const T&) overload without `maxSize` for static containers");
             auto size = traits::ContainerTraits<T>::size(obj);
             assert(size <= maxSize);
-            details::writeSize(_writer, size);
+            details::writeSize(this->_adapter, size);
             procContainer(std::begin(obj), std::end(obj));
         }
 
@@ -254,10 +350,6 @@ namespace bitsery {
             procContainer(std::begin(obj), std::end(obj));
         }
 
-        void align() {
-            _writer.align();
-        }
-
         //overloads for functions with explicit type size
 
         template<typename T>
@@ -326,12 +418,8 @@ namespace bitsery {
         template<typename T>
         void container8b(T &&obj) { container<8>(std::forward<T>(obj)); }
 
-    private:
-        friend AdapterAccess;
 
-        TAdapterWriter _writer;
-        TContext* _context;
-        typename TWriter::TConfig::InternalContext _internalContext;
+    private:
 
         //process value types
         //false_type means that we must process all elements individually
@@ -348,7 +436,7 @@ namespace bitsery {
             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)),
+				this->_adapter.template writeBuffer<VSIZE>(reinterpret_cast<const TIntegral*>(&(*first)),
                                                     static_cast<size_t>(std::distance(first, last)));
         }
 
@@ -357,7 +445,7 @@ namespace bitsery {
         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));
+                fnc(*this, const_cast<TValue&>(*first));
             }
         }
 
@@ -366,7 +454,7 @@ namespace bitsery {
         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);
+            details::writeSize(this->_adapter, length);
             auto begin = std::begin(str);
             procContainer<VSIZE>(begin, std::next(begin, length), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
         }
@@ -380,24 +468,31 @@ namespace bitsery {
 
         //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);
+            this->_adapter.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));
+            this->_adapter.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) {
+        template <typename Fnc, typename HasContext>
+        void procEnableBitPacking(const Fnc& fnc, std::true_type, HasContext) {
             fnc(*this);
         }
 
         template <typename Fnc>
-        void procEnableBitPacking(const Fnc& fnc, std::false_type) {
+        void procEnableBitPacking(const Fnc& fnc, std::false_type, std::true_type) {
             //create serializer using bitpacking wrapper
-            BPEnabledType tmp(_writer, _context);
-            fnc(tmp);
+            BPEnabledType ser{this->_context, this->_adapter};
+            fnc(ser);
+        }
+
+        template <typename Fnc>
+        void procEnableBitPacking(const Fnc& fnc, std::false_type, std::false_type) {
+            //create serializer using bitpacking wrapper
+            BPEnabledType ser{this->_adapter};
+            fnc(ser);
         }
 
         //these are dummy functions for extensions that have TValue = void
@@ -410,33 +505,34 @@ namespace bitsery {
 
         }
 
+        template<typename T, typename ... TArgs>
+        void archive(T &&head, TArgs &&... tail) {
+            //serialize object
+            details::BriefSyntaxFunction<Serializer, T>::invoke(*this, std::forward<T>(head));
+            //expand other elements
+            archive(std::forward<TArgs>(tail)...);
+        }
         //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)};
+    template <typename OutputAdapter, typename T>
+    size_t quickSerialization(OutputAdapter adapter, const T& value) {
+        Serializer<OutputAdapter> ser{std::move(adapter)};
         ser.object(value);
-        auto& w = AdapterAccess::getWriter(ser);
-        w.flush();
-        return w.writtenBytesCount();
+        ser.adapter().flush();
+        return ser.adapter().writtenBytesCount();
     }
 
-    template <typename T>
-    size_t quickMeasureSize(const T& value) {
-        BasicSerializer<MeasureSize> ser {nullptr};
+    template <typename Context, typename OutputAdapter, typename T>
+    size_t quickSerialization(Context& ctx, OutputAdapter adapter, const T& value) {
+        Serializer<OutputAdapter, Context> ser{ctx, std::move(adapter)};
         ser.object(value);
-        auto& w = AdapterAccess::getWriter(ser);
-        w.flush();
-        return w.writtenBytesCount();
+        ser.adapter().flush();
+        return ser.adapter().writtenBytesCount();
     }
 
 }

include/bitsery/traits/core/std_defaults.h

@@ -24,7 +24,7 @@
 #define BITSERY_TRAITS_CORE_STD_DEFAULTS_H
 
 #include "traits.h"
-#include <iostream>
+#include "../../details/serialization_common.h"
 
 namespace bitsery {
     namespace traits {
@@ -53,13 +53,28 @@ namespace bitsery {
                 return container.size();
             }
             static void resize(T& container, size_t size) {
+                resizeImpl(container, size, std::is_default_constructible<TValue>{});
+            }
+        private:
+            static void resizeImpl(T& container, size_t size, std::true_type) {
                 container.resize(size);
             }
+            static void resizeImpl(T& container, size_t newSize, std::false_type) {
+                const auto oldSize = size(container);
+                for (auto it = oldSize; it < newSize; ++it) {
+                    container.push_back(::bitsery::Access::create<TValue>());
+                }
+                if (oldSize > newSize) {
+                    container.erase(std::next(std::begin(container), newSize));
+                }
+            }
+
         };
 
         template <typename T, bool Resizable = ContainerTraits<T>::isResizable>
         struct StdContainerForBufferAdapter {
             using TIterator = typename T::iterator;
+            using TConstIterator = typename T::const_iterator;
             using TValue = typename ContainerTraits<T>::TValue;
         };
 
@@ -76,6 +91,7 @@ namespace bitsery {
                 container.resize((std::max)(newSize, container.capacity()));
             }
             using TIterator = typename T::iterator;
+            using TConstIterator = typename T::const_iterator;
             using TValue = typename ContainerTraits<T>::TValue;
         };
 

include/bitsery/traits/core/traits.h

@@ -147,7 +147,6 @@ namespace bitsery {
             //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,
@@ -155,6 +154,7 @@ namespace bitsery {
             }
 
             using TIterator = details::NotDefinedType;
+            using TConstIterator = details::NotDefinedType;
             using TValue = typename ContainerTraits<T>::TValue;
         };
 
@@ -162,6 +162,7 @@ namespace bitsery {
         template <typename T, size_t N>
         struct BufferAdapterTraits<T[N]> {
             using TIterator = T*;
+            using TConstIterator = const T*;
             using TValue = T;
         };
 
@@ -169,12 +170,14 @@ namespace bitsery {
         template <typename T>
         struct BufferAdapterTraits<const T*> {
             using TIterator = const T*;
+            using TConstIterator = const T*;
             using TValue = T;
         };
 
         template <typename T>
         struct BufferAdapterTraits<T*> {
             using TIterator = T*;
+            using TConstIterator = const T*;
             using TValue = T;
         };
 

include/bitsery/traits/deque.h

@@ -31,9 +31,9 @@ namespace bitsery {
 
     namespace traits {
 
-        template<typename ... TArgs>
-        struct ContainerTraits<std::deque<TArgs...>>
-                : public StdContainer<std::deque<TArgs...>, true, false> {};
+        template<typename T, typename Allocator>
+        struct ContainerTraits<std::deque<T, Allocator>>
+                : public StdContainer<std::deque<T, Allocator>, true, false> {};
 
     }
 

include/bitsery/traits/forward_list.h

@@ -24,23 +24,42 @@
 #ifndef BITSERY_TRAITS_STD_FORWARD_LIST_H
 #define BITSERY_TRAITS_STD_FORWARD_LIST_H
 
+#include "core/traits.h"
+#include "../details/serialization_common.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;
+        template<typename T, typename Allocator>
+        struct ContainerTraits<std::forward_list<T, Allocator>> {
+            using TValue = T;
             static constexpr bool isResizable = true;
             static constexpr bool isContiguous = false;
-            static size_t size(const std::forward_list<TArgs...>& container) {
+            static size_t size(const std::forward_list<T, Allocator>& container) {
                 return static_cast<size_t>(std::distance(container.begin(), container.end()));
             }
-            static void resize(std::forward_list<TArgs...>& container, size_t size) {
+            static void resize(std::forward_list<T, Allocator>& container, size_t size) {
+                resizeImpl(container, size, std::is_default_constructible<TValue>{});
+            }
+        private:
+            static void resizeImpl(std::forward_list<T, Allocator>& container, size_t size, std::true_type) {
                 container.resize(size);
             }
+            static void resizeImpl(std::forward_list<T, Allocator>& container, size_t newSize, std::false_type) {
+                const auto oldSize = size(container);
+                for (auto it = oldSize; it < newSize; ++it) {
+                    container.push_front(::bitsery::Access::create<TValue>());
+                }
+                if (oldSize > newSize) {
+                    //erase_after must have atleast one element to work
+                    if (newSize > 0)
+                        container.erase_after(std::next(std::begin(container), newSize-1));
+                    else
+                        container.clear();
+                }
+            }
         };
     }
 }

include/bitsery/traits/list.h

@@ -31,9 +31,9 @@ namespace bitsery {
 
     namespace traits {
 
-        template<typename ... TArgs>
-        struct ContainerTraits<std::list<TArgs...>>
-                : public StdContainer<std::list<TArgs...>, true, false> {};
+        template<typename T, typename Allocator>
+        struct ContainerTraits<std::list<T, Allocator>>
+                : public StdContainer<std::list<T, Allocator>, true, false> {};
 
     }
 

include/bitsery/traits/string.h

@@ -33,18 +33,18 @@ namespace bitsery {
 
         // 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 CharT, typename Traits, typename Allocator>
+        struct ContainerTraits<std::basic_string<CharT, Traits, Allocator>>
+            :public StdContainer<std::basic_string<CharT, Traits, Allocator>, true, true> {};
 
-        template <typename ... TArgs>
-        struct TextTraits<std::basic_string<TArgs...>> {
-            using TValue = typename ContainerTraits<std::basic_string<TArgs...>>::TValue;
+        template <typename CharT, typename Traits, typename Allocator>
+        struct TextTraits<std::basic_string<CharT, Traits, Allocator>> {
+            using TValue = typename ContainerTraits<std::basic_string<CharT, Traits, Allocator>>::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) {
+            static size_t length(const std::basic_string<CharT, Traits, Allocator>& str) {
                 return str.size();
             }
         };
@@ -60,9 +60,9 @@ namespace bitsery {
             }
         };
 
-        template<typename ... TArgs>
-        struct BufferAdapterTraits<std::basic_string<TArgs...>>
-                :public StdContainerForBufferAdapter<std::basic_string<TArgs...>> {};
+        template<typename CharT, typename Traits, typename Allocator>
+        struct BufferAdapterTraits<std::basic_string<CharT, Traits, Allocator>>
+                :public StdContainerForBufferAdapter<std::basic_string<CharT, Traits, Allocator>> {};
 
     }
 

include/bitsery/traits/vector.h

@@ -30,18 +30,18 @@
 namespace bitsery {
 
     namespace traits {
-        template<typename ... TArgs>
-        struct ContainerTraits<std::vector<TArgs...>>
-                :public StdContainer<std::vector<TArgs...>, true, true> {};
+        template<typename T, typename Allocator>
+        struct ContainerTraits<std::vector<T, Allocator>>
+                :public StdContainer<std::vector<T, Allocator>, 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...>> {};
+        template<typename T, typename Allocator>
+        struct BufferAdapterTraits<std::vector<T, Allocator>>
+                :public StdContainerForBufferAdapter<std::vector<T, Allocator>> {};
 
     }
 

scripts/CTestConfig.cmake

@@ -4,4 +4,3 @@ 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

@@ -6,7 +6,6 @@ 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")
 

scripts/show_coverage.sh

@@ -5,4 +5,4 @@ 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
+x-www-browser $TESTS_BUILD_DIR/coverage_web/index.html

tests/CMakeLists.txt

@@ -20,7 +20,7 @@
 #OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #SOFTWARE.
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.10)
 project(bitsery_tests CXX)
 
 find_package(GTest 1.8 REQUIRED)
@@ -31,11 +31,6 @@ endif()
 
 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)
-endif()
-
 enable_testing()
 
 foreach (TestFile ${TestSourceFiles})
@@ -46,8 +41,9 @@ foreach (TestFile ${TestSourceFiles})
     if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
         target_compile_options(${TestName} PRIVATE -Wextra -Wno-missing-braces -Wpedantic -Weffc++ -Wno-c++14-extensions)
     endif()
+    gtest_discover_tests(${TestName})
 
-    add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)
+#    add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)
 endforeach()
 
 #======================= setup development environment ====================

tests/adapter.cpp

@@ -0,0 +1,560 @@
+//MIT License
+//
+//Copyright (c) 2019 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 <bitsery/adapter/buffer.h>
+#include <bitsery/adapter/stream.h>
+#include <bitsery/adapter/measure_size.h>
+#include <bitsery/deserializer.h>
+#include <bitsery/traits/vector.h>
+#include <bitsery/traits/array.h>
+#include <bitsery/traits/string.h>
+
+#include <gmock/gmock.h>
+
+//some helper types
+using Buffer = std::vector<char>;
+using OutputAdapter = bitsery::OutputBufferAdapter<Buffer>;
+using InputAdapter = bitsery::InputBufferAdapter<Buffer>;
+
+using bitsery::ReaderError;
+
+using testing::Eq;
+using testing::Ge;
+
+struct DisableAdapterErrorsConfig {
+    static constexpr bitsery::EndiannessType Endianness = bitsery::DefaultConfig::Endianness;
+    static constexpr bool CheckAdapterErrors = false;
+    static constexpr bool CheckDataErrors = true;
+};
+
+TEST(OutputBuffer, WhenInitialBufferIsEmptyThenResizeInAdapterConstructor) {
+    //setup data
+    Buffer buf{};
+    EXPECT_THAT(buf.size(), Eq(0));
+    OutputAdapter adapter{buf};
+    EXPECT_THAT(buf.size(), Ge(1));
+}
+
+TEST(OutputBuffer, WhenSetWritePositionThenResizeUnderlyingBufferIfRequired) {
+    //setup data
+    Buffer buf{};
+    OutputAdapter w{buf};
+    const auto initialSize = buf.size();
+    EXPECT_THAT(buf.size(), Eq(initialSize));
+    EXPECT_THAT(w.currentWritePos(), Eq(0));
+    w.currentWritePos(initialSize + 10);
+    EXPECT_THAT(w.currentWritePos(), Eq(initialSize + 10));
+    EXPECT_THAT(buf.size(), Ge(initialSize + 10));
+}
+
+TEST(OutputBuffer, WhenSettingCurrentPositionBeforeBufferEndThenWrittenBytesCountIsNotAffected) {
+    //setup data
+    Buffer buf{};
+    OutputAdapter w{buf};
+    const auto initialSize = buf.size();
+    EXPECT_THAT(buf.size(), Eq(initialSize));
+    EXPECT_THAT(w.writtenBytesCount(), Eq(0));
+    w.currentWritePos(initialSize + 10);
+    w.writeBytes<8>(static_cast<uint64_t>(1));
+    EXPECT_THAT(w.writtenBytesCount(), Eq(initialSize + 10 + 8));
+    w.currentWritePos(0);
+    EXPECT_THAT(w.writtenBytesCount(), Eq(initialSize + 10 + 8));
+}
+
+TEST(OutputBuffer, CanWorkWithFixedSizeBuffer) {
+    //setup data
+    std::array<uint8_t, 10> buf{};
+    bitsery::OutputBufferAdapter<std::array<uint8_t, 10>> w{buf};
+    const auto initialSize = buf.size();
+    EXPECT_THAT(buf.size(), Eq(initialSize));
+    EXPECT_THAT(w.currentWritePos(), Eq(0));
+    w.currentWritePos(5);
+    EXPECT_THAT(w.currentWritePos(), Eq(5));
+}
+
+TEST(InputBuffer, CorrectlySetsAndGetsCurrentReadPosition) {
+
+    Buffer buf{};
+    buf.resize(100);
+    InputAdapter r{buf.begin(), 10};
+    r.currentReadPos(5);
+    EXPECT_THAT(r.currentReadPos(), Eq(5));
+    r.currentReadPos(0);
+    EXPECT_THAT(r.currentReadPos(), Eq(0));
+    uint8_t tmp;
+    r.readBytes<1>(tmp);
+    EXPECT_THAT(r.currentReadPos(), Eq(1));
+}
+
+
+TEST(InputBuffer, WhenSetReadPositionOutOfRangeThenDataOverflow) {
+
+    Buffer buf{};
+    buf.resize(100);
+    InputAdapter r{buf.begin(), 10};
+    r.currentReadPos(10);
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    r.currentReadPos(11);
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+}
+
+TEST(InputBuffer, WhenSetReadEndPositionOutOfRangeThenDataOverflow) {
+    Buffer buf{};
+    buf.resize(100);
+    InputAdapter r{buf.begin(), 10};
+    r.currentReadEndPos(11);
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+}
+
+TEST(InputBuffer, WhenReadEndPositionIsNotSetThenReturnZeroAsBufferEndPosition) {
+    Buffer buf{};
+    buf.resize(100);
+    InputAdapter r{buf.begin(), 10};
+    EXPECT_THAT(r.currentReadEndPos(), Eq(0));
+    r.currentReadEndPos(5);
+    EXPECT_THAT(r.currentReadEndPos(), Eq(5));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+}
+
+
+TEST(InputBuffer, WhenReadEndPositionIsNotZeroThenDataOverflowErrorWillBeIgnored) {
+    Buffer buf{};
+    buf.resize(100);
+    InputAdapter r{buf.begin(), 1};
+    r.currentReadEndPos(1);
+    uint32_t tmp{};
+    r.readBytes<4>(tmp);
+    EXPECT_THAT(tmp, Eq(0));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    r.currentReadEndPos(0);
+    r.readBytes<4>(tmp);
+    EXPECT_THAT(tmp, Eq(0));
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+}
+
+
+TEST(InputBuffer, WhenReadingPastReadEndPositionOrBufferEndThenReadPositionDoesntChange) {
+    Buffer buf{};
+    buf.resize(10);
+    InputAdapter r{buf.begin(), 3};
+    uint32_t tmp{};
+    r.currentReadEndPos(2);
+    r.readBytes<4>(tmp);
+    EXPECT_THAT(r.currentReadPos(), Eq(0));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    EXPECT_THAT(tmp, Eq(0));
+    r.currentReadEndPos(0);
+    r.readBytes<4>(tmp);
+    EXPECT_THAT(r.currentReadPos(), Eq(0));
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+    EXPECT_THAT(tmp, Eq(0));
+}
+
+TEST(InputBuffer, WhenReaderHasErrorsThenSettingReadPosAndReadEndPosIsIgnoredAndGettingAlwaysReturnsZero) {
+    Buffer buf{};
+    buf.resize(10);
+    InputAdapter r{buf.begin(), 10};
+    uint32_t tmp{};
+    r.readBytes<4>(tmp);
+    r.currentReadEndPos(5);
+    EXPECT_THAT(r.currentReadPos(), Eq(4));
+    EXPECT_THAT(r.currentReadEndPos(), Eq(5));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    r.currentReadEndPos(11);
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+    EXPECT_THAT(r.currentReadPos(), Eq(0));
+    EXPECT_THAT(r.currentReadEndPos(), Eq(0));
+    r.currentReadPos(1);
+    r.currentReadEndPos(1);
+    EXPECT_THAT(r.currentReadPos(), Eq(0));
+    EXPECT_THAT(r.currentReadEndPos(), Eq(0));
+}
+
+TEST(InputBuffer, ConstDataForBufferAllAdapters) {
+    //create and write to buffer
+    uint16_t data = 7549;
+    Buffer bufWrite{};
+    OutputAdapter bw{bufWrite};
+    bw.writeBytes<2>(data);
+    bw.flush();
+    const Buffer buf{bufWrite};
+
+    //read from buffer
+
+    bitsery::InputBufferAdapter<const Buffer> r1{buf.begin(), buf.end()};
+
+    uint16_t res1{};
+    r1.readBytes<2>(res1);
+    EXPECT_THAT(res1, Eq(data));
+}
+
+#ifndef NDEBUG
+TEST(InputBuffer, WhenAdapterErrorsIsDisabledThenCanChangeAnyReadPositionAndReadsAsserts) {
+    //create and write to buffer
+    uint64_t data = 0x1122334455667788;
+    Buffer buf{};
+    OutputAdapter bw{buf};
+    bw.writeBytes<8>(data);
+    bw.flush();
+
+    bitsery::InputBufferAdapter<Buffer, DisableAdapterErrorsConfig> r1{buf.begin(), 2};
+    uint16_t res1{};
+    r1.readBytes<2>(res1);
+    EXPECT_THAT(res1, Eq(0x7788)); // default config is little endian
+    EXPECT_THAT(r1.currentReadPos(), Eq(2));
+    r1.currentReadPos(4);
+    EXPECT_THAT(r1.currentReadPos(), Eq(4));
+    EXPECT_DEATH(r1.readBytes<2>(res1), ""); // default config is little endian
+}
+#endif
+
+TEST(InputStream, WhenAdapterErrorsIsDisabledThenReadingPastEndDoesntSetErrorAndDoesntReturnZero) {
+    //create and write to buffer
+    std::stringstream ss{};
+    bitsery::OutputStreamAdapter bw{ss};
+    uint32_t data = 0x12345678;
+    bw.writeBytes<4>(data);
+    bw.flush();
+
+    bitsery::BasicInputStreamAdapter<char, DisableAdapterErrorsConfig, std::char_traits<char>> br{ss};
+    uint32_t res{};
+    br.readBytes<4>(res);
+    EXPECT_THAT(res, Eq(data));
+    br.readBytes<4>(res);
+    EXPECT_THAT(res, Eq(data));
+    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(true));
+}
+
+template <template<typename...> class TAdapter>
+struct InBufferConfig {
+    using Data = std::vector<char>;
+    using Adapter = TAdapter<Data>;
+
+    Data data{};
+    Adapter createReader(const std::vector<char>& buffer) {
+        data = buffer;
+        return Adapter{data.begin(), data.size()};
+    }
+};
+
+template <typename TAdapter>
+struct InStreamConfig {
+    using Data = std::stringstream;
+    using Adapter = TAdapter;
+
+    Data data{};
+    Adapter createReader(const std::vector<char>& buffer) {
+        std::string str(buffer.begin(), buffer.end());
+        data = std::stringstream{str};
+        return Adapter{data};
+    }
+};
+
+template<typename TAdapterWithData>
+class AdapterConfig : public testing::Test {
+public:
+
+    TAdapterWithData config{};
+};
+
+using AdapterInputTypes = ::testing::Types<
+    InBufferConfig<bitsery::InputBufferAdapter>,
+    InStreamConfig<bitsery::InputStreamAdapter>
+>;
+
+template <typename TConfig>
+class InputAll: public AdapterConfig<TConfig> {
+};
+
+TYPED_TEST_CASE(InputAll, AdapterInputTypes);
+
+
+TYPED_TEST(InputAll, SettingMultipleErrorsAlwaysReturnsFirstError) {
+    auto r = this->config.createReader({0,0,0,0});
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    r.error(ReaderError::InvalidPointer);
+    EXPECT_THAT(r.error(), Eq(ReaderError::InvalidPointer));
+    r.error(ReaderError::DataOverflow);
+    EXPECT_THAT(r.error(), Eq(ReaderError::InvalidPointer));
+    r.error(ReaderError::NoError);
+    EXPECT_THAT(r.error(), Eq(ReaderError::InvalidPointer));
+}
+
+TYPED_TEST(InputAll, CanBeMoveConstructedAndMoveAssigned) {
+    auto r = this->config.createReader({1,2,3});
+    uint8_t res{};
+    r.template readBytes<1>(res);
+    EXPECT_THAT(res, Eq(1));
+    // move construct
+    auto r1 = std::move(r);
+    r1.template readBytes<1>(res);
+    EXPECT_THAT(res, Eq(2));
+    // move assign
+    r = std::move(r1);
+    r.template readBytes<1>(res);
+    EXPECT_THAT(res, Eq(3));
+}
+
+
+TYPED_TEST(InputAll, WhenAlignHasNonZerosThenInvalidDataError) {
+
+    auto r = this->config.createReader({0x7F});
+    bitsery::details::InputAdapterBitPackingWrapper<decltype(r)> bpr{r};
+
+    uint8_t tmp{0xFF};
+    bpr.readBits(tmp,3);
+    bpr.align();
+    EXPECT_THAT(bpr.error(), Eq(ReaderError::InvalidData));
+}
+
+
+TYPED_TEST(InputAll, WhenAllBytesAreReadWithoutErrorsThenIsCompletedSuccessfully) {
+    //setup data
+
+    uint32_t tb = 94545646;
+    int16_t tc = -8778;
+    uint8_t td = 200;
+
+    //create and write to buffer
+    Buffer buf{};
+    OutputAdapter bw{buf};
+
+    bw.writeBytes<4>(tb);
+    bw.writeBytes<2>(tc);
+    bw.writeBytes<1>(td);
+    bw.flush();
+    buf.resize(bw.writtenBytesCount());
+
+    auto br = this->config.createReader(buf);
+
+    uint32_t rb = 94545646;
+    int16_t rc = -8778;
+    uint8_t rd = 200;
+
+    br.template readBytes<4>(rb);
+    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
+    br.template readBytes<2>(rc);
+    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
+    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
+    br.template readBytes<1>(rd);
+    EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
+    EXPECT_THAT(br.isCompletedSuccessfully(), Eq(true));
+
+    EXPECT_THAT(rb, Eq(tb));
+    EXPECT_THAT(rc, Eq(tc));
+    EXPECT_THAT(rd, Eq(td));
+}
+
+
+TYPED_TEST(InputAll, WhenReadingMoreThanAvailableThenDataOverflow) {
+    //setup data
+    uint8_t t1 = 111;
+
+    Buffer buf{};
+    OutputAdapter w{buf};
+    w.writeBytes<1>(t1);
+    w.flush();
+    buf.resize(w.writtenBytesCount());
+
+    auto r = this->config.createReader(buf);
+
+    uint8_t r1{};
+    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(false));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    r.template readBytes<1>(r1);
+    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(true));
+    EXPECT_THAT(r.error(), Eq(ReaderError::NoError));
+    EXPECT_THAT(r1, Eq(t1));
+    r.template readBytes<1>(r1);
+    r.template readBytes<1>(r1);
+    EXPECT_THAT(r1, Eq(0));
+    EXPECT_THAT(r.isCompletedSuccessfully(), Eq(false));
+    EXPECT_THAT(r.error(), Eq(ReaderError::DataOverflow));
+
+}
+
+TYPED_TEST(InputAll, WhenReaderHasErrorsAllThenReadsReturnZero) {
+    //setup data
+    uint8_t t1 = 111;
+
+    Buffer buf{};
+    OutputAdapter w{buf};
+    w.writeBytes<1>(t1);
+    w.writeBytes<1>(t1);
+    w.flush();
+    buf.resize(w.writtenBytesCount());
+
+    auto r = this->config.createReader(buf);
+
+    uint8_t r1{};
+    r.template readBytes<1>(r1);
+    EXPECT_THAT(r1, Eq(t1));
+    r.error(ReaderError::InvalidPointer);
+    r.template readBytes<1>(r1);
+    EXPECT_THAT(r1, Eq(0));
+}
+
+
+template <template<typename...> class TAdapter>
+struct OutBufferConfig {
+    using Data = std::vector<char>;
+    using Adapter = TAdapter<Data>;
+
+    Data data{};
+    Adapter createWriter() {
+        return Adapter{data};
+    }
+
+    bitsery::InputBufferAdapter<Data> getReader() {
+        return bitsery::InputBufferAdapter<Data>{data.begin(), data.end()};
+    }
+};
+
+template <typename TAdapter>
+struct OutStreamConfig {
+    using Data = std::stringstream;
+    using Adapter = TAdapter;
+
+    Data data{};
+    Adapter createWriter() {
+        return Adapter{data};
+    }
+
+    bitsery::InputStreamAdapter getReader() {
+        return bitsery::InputStreamAdapter{data};
+    }
+};
+
+using AdapterOutputTypes = ::testing::Types<
+    OutBufferConfig<bitsery::OutputBufferAdapter>,
+    OutStreamConfig<bitsery::OutputStreamAdapter>,
+    OutStreamConfig<bitsery::OutputBufferedStreamAdapter>
+>;
+
+template <typename TConfig>
+class OutputAll: public AdapterConfig<TConfig> {
+};
+
+TYPED_TEST_CASE(OutputAll, AdapterOutputTypes);
+
+TYPED_TEST(OutputAll, CanBeMoveConstructedAndMoveAssigned) {
+    auto w = this->config.createWriter();
+    uint8_t data{1};
+    w.template writeBytes<1>(data);
+    // move construct
+    auto w1 = std::move(w);
+    data = 2;
+    w1.template writeBytes<1>(data);
+    // move assignment
+    w = std::move(w1);
+    data = 3;
+    w.template writeBytes<1>(data);
+    w.flush();
+
+    auto r = this->config.getReader();
+    r.template readBytes<1>(data);
+    EXPECT_THAT(data, Eq(1));
+    r.template readBytes<1>(data);
+    EXPECT_THAT(data, Eq(2));
+    r.template readBytes<1>(data);
+    EXPECT_THAT(data, Eq(3));
+}
+
+
+template<typename T>
+class OutputStreamBuffered : public testing::Test {
+public:
+    using Buffer = T;
+    using Adapter = bitsery::BasicBufferedOutputStreamAdapter<char, bitsery::DefaultConfig, std::char_traits<char>, Buffer>;
+
+    static constexpr size_t InternalBufferSize = 128;
+
+    std::stringstream stream{};
+
+    Adapter writer{stream, 128};
+};
+
+using BufferedAdapterInternalBufferTypes = ::testing::Types<
+    std::vector<char>,
+    std::array<char, 128>,
+    std::string
+>;
+
+TYPED_TEST_CASE(OutputStreamBuffered, BufferedAdapterInternalBufferTypes);
+
+TYPED_TEST(OutputStreamBuffered, WhenInternalBufferIsFullThenWriteBufferAndRemainingDataToStream) {
+    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(OutputStreamBuffered, 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(OutputStreamBuffered, 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::Adapter 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));
+}
+
+TEST(AdapterWriterMeasureSize, CorrectlyMeasuresWrittenBytesCountForSerialization) {
+    bitsery::MeasureSize w{};
+    EXPECT_THAT(w.writtenBytesCount(), Eq(0));
+    w.writeBytes<8>(uint64_t{0});
+    EXPECT_THAT(w.writtenBytesCount(), Eq(8));
+    w.writeBuffer<8, uint64_t>(nullptr, 9);
+    EXPECT_THAT(w.writtenBytesCount(), Eq(80));
+    w.currentWritePos(10);
+    w.writeBytes<4>(uint32_t{0});
+    EXPECT_THAT(w.writtenBytesCount(), Eq(80));
+    EXPECT_THAT(w.currentWritePos(), Eq(14));
+    w.currentWritePos(80);
+    EXPECT_THAT(w.writtenBytesCount(), Eq(80));
+    w.writeBits(uint32_t{0}, 7u);
+    EXPECT_THAT(w.writtenBytesCount(), Eq(80));
+    w.align();
+    EXPECT_THAT(w.writtenBytesCount(), Eq(81));
+    w.writeBits(uint32_t{0}, 7u);
+    w.flush();
+    EXPECT_THAT(w.writtenBytesCount(), Eq(82));
+    // doesn't compile on older compilers if I write bitsery::MeasureSize::BitPackingEnabled directly in EXPECT_THAT macro.
+    constexpr bool bpEnabled = bitsery::MeasureSize::BitPackingEnabled;
+    EXPECT_THAT(bpEnabled, Eq(true));
+}

tests/adapter_stream.cpp

@@ -1,162 +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 <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 <gmock/gmock.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/brief_syntax.cpp

@@ -20,35 +20,45 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-
-#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>
-#include <bitsery/flexible/memory.h>
+#include <bitsery/brief_syntax.h>
+#include <bitsery/brief_syntax/array.h>
+#include <bitsery/brief_syntax/chrono.h>
+#include <bitsery/brief_syntax/deque.h>
+#include <bitsery/brief_syntax/forward_list.h>
+#include <bitsery/brief_syntax/list.h>
+#include <bitsery/brief_syntax/map.h>
+#include <bitsery/brief_syntax/memory.h>
+#include <bitsery/brief_syntax/queue.h>
+#include <bitsery/brief_syntax/set.h>
+#include <bitsery/brief_syntax/stack.h>
+#include <bitsery/brief_syntax/string.h>
+#include <bitsery/brief_syntax/unordered_map.h>
+#include <bitsery/brief_syntax/unordered_set.h>
+#include <bitsery/brief_syntax/vector.h>
+#if __cplusplus > 201402L
+#include <bitsery/brief_syntax/tuple.h>
+#include <bitsery/brief_syntax/variant.h>
+#else
+#if defined(_MSC_VER)
+#pragma message("tuple and variant only works with c++17")
+#else
+#warning "tuple and variant only works with c++17"
+#endif
+#endif
 
 #include <gmock/gmock.h>
 #include "serialization_test_utils.h"
 
 using testing::Eq;
 
-TEST(FlexibleSyntax, FundamentalTypesAndBool) {
+TEST(BriefSyntax, 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);
+    ctx.createSerializer()(ti, te, tf, td, tb);
 
     //result
     int ri{};
@@ -56,7 +66,7 @@ TEST(FlexibleSyntax, FundamentalTypesAndBool) {
     float rf{};
     double rd{};
     bool rb{};
-    ctx.createDeserializer().archive(ri, re, rf, rd, rb);
+    ctx.createDeserializer()(ri, re, rf, rd, rb);
 
     //test
     EXPECT_THAT(ri, Eq(ti));
@@ -66,14 +76,14 @@ TEST(FlexibleSyntax, FundamentalTypesAndBool) {
     EXPECT_THAT(rb, Eq(tb));
 }
 
-TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
+TEST(BriefSyntax, 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();
+    auto& ser = ctx.createSerializer();
     ser.object(ti);
     ser.object(te);
     ser.object(tf);
@@ -86,7 +96,7 @@ TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
     float rf{};
     double rd{};
     bool rb{};
-    auto &des = ctx.createDeserializer();
+    auto& des = ctx.createDeserializer();
     des.object(ri);
     des.object(re);
     des.object(rf);
@@ -101,16 +111,16 @@ TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
     EXPECT_THAT(rb, Eq(tb));
 }
 
-TEST(FlexibleSyntax, MixDifferentSyntax) {
+TEST(BriefSyntax, 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();
+    auto& ser = ctx.createSerializer();
     ser.value<sizeof(ti)>(ti);
-    ser.archive(te, tf, td);
+    ser(te, tf, td);
     ser.object(tb);
 
     //result
@@ -119,8 +129,8 @@ TEST(FlexibleSyntax, MixDifferentSyntax) {
     float rf{};
     double rd{};
     bool rb{};
-    auto &des = ctx.createDeserializer();
-    des.archive(ri, re, rf);
+    auto& des = ctx.createDeserializer();
+    des(ri, re, rf);
     des.value8b(rd);
     des.object(rb);
 
@@ -133,130 +143,130 @@ TEST(FlexibleSyntax, MixDifferentSyntax) {
 }
 
 template<typename T>
-T procArchive(const T& testData) {
+T procBriefSyntax(const T& testData) {
     SerializationContext ctx;
-    ctx.createSerializer().archive(testData);
+    ctx.createSerializer()(testData);
     T res{};
-    ctx.createDeserializer().archive(res);
+    ctx.createDeserializer()(res);
     return res;
 }
 
 template<typename T>
-T procArchiveWithMaxSize(const T& testData) {
+T procBriefSyntaxWithMaxSize(const T& testData) {
     SerializationContext ctx;
-    ctx.createSerializer().archive(bitsery::maxSize(testData, 100));
+    ctx.createSerializer()(bitsery::maxSize(testData, 100));
     T res{};
-    ctx.createDeserializer().archive(bitsery::maxSize(res, 100));
+    ctx.createDeserializer()(bitsery::maxSize(res, 100));
     return res;
 }
 
-TEST(FlexibleSyntax, CStyleArrayForValueTypesAsContainer) {
+TEST(BriefSyntax, 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));
+    ctx.createSerializer()(bitsery::asContainer(t1));
+    ctx.createDeserializer()(bitsery::asContainer(r1));
 
     EXPECT_THAT(r1, ::testing::ContainerEq(t1));
 }
 
-TEST(FlexibleSyntax, CStyleArrayForIntegralTypesAsText) {
+TEST(BriefSyntax, 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));
+    ctx.createSerializer()(bitsery::asText(t1));
+    ctx.createDeserializer()(bitsery::asText(r1));
 
     EXPECT_THAT(r1, ::testing::ContainerEq(t1));
 }
 
-TEST(FlexibleSyntax, CStyleArray) {
+TEST(BriefSyntax, CStyleArray) {
     const MyEnumClass t1[3]{MyEnumClass::E1, MyEnumClass::E4, MyEnumClass::E2};
     MyEnumClass r1[3]{};
 
     SerializationContext ctx;
-    ctx.createSerializer().archive(t1);
-    ctx.createDeserializer().archive(r1);
+    ctx.createSerializer()(t1);
+    ctx.createDeserializer()(r1);
 
     EXPECT_THAT(r1, ::testing::ContainerEq(t1));
 }
 
-TEST(FlexibleSyntax, StdString) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdArray) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdVector) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdList) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdForwardList) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdDeque) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntax(t2), Eq(t2));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t2), Eq(t2));
 }
 
-TEST(FlexibleSyntax, StdQueue) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
 }
 
-TEST(FlexibleSyntax, StdPriorityQueue) {
+TEST(BriefSyntax, StdPriorityQueue) {
     std::priority_queue<std::string> t1;
     t1.push("first");
     t1.push("second string");
     t1.push("third");
     t1.push("fourth");
-    auto r1 = procArchive(t1);
+    auto r1 = procBriefSyntax(t1);
     //we cannot compare priority queue directly
 
     EXPECT_THAT(r1.size(), Eq(t1.size()));
@@ -267,50 +277,50 @@ TEST(FlexibleSyntax, StdPriorityQueue) {
     }
 }
 
-TEST(FlexibleSyntax, StdStack) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
 }
 
-TEST(FlexibleSyntax, StdUnorderedMap) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
 }
 
-TEST(FlexibleSyntax, StdUnorderedMultiMap) {
+TEST(BriefSyntax, 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);
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+    EXPECT_TRUE(procBriefSyntaxWithMaxSize(t1) == t1);
 }
 
-TEST(FlexibleSyntax, StdMap) {
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
 }
 
-TEST(FlexibleSyntax, StdMultiMap) {
+TEST(BriefSyntax, StdMultiMap) {
     std::multimap<std::string, int> t1;
     t1.emplace("one", 624);
     t1.emplace("two", -845);
     t1.emplace("one", 897);
 
-    auto res = procArchive(t1);
+    auto res = procBriefSyntax(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));
@@ -323,38 +333,38 @@ TEST(FlexibleSyntax, StdMultiMap) {
     }
 }
 
-TEST(FlexibleSyntax, StdUnorderedSet) {
+TEST(BriefSyntax, 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);
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+    EXPECT_TRUE(procBriefSyntaxWithMaxSize(t1) == t1);
 }
 
-TEST(FlexibleSyntax, StdUnorderedMultiSet) {
+TEST(BriefSyntax, 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);
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+    EXPECT_TRUE(procBriefSyntaxWithMaxSize(t1) == t1);
 }
 
-TEST(FlexibleSyntax, StdSet) {
+TEST(BriefSyntax, 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);
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+    EXPECT_TRUE(procBriefSyntaxWithMaxSize(t1) == t1);
 }
 
-TEST(FlexibleSyntax, StdMultiSet) {
+TEST(BriefSyntax, StdMultiSet) {
     std::multiset<std::string> t1;
     t1.emplace("one");
     t1.emplace("two");
@@ -362,23 +372,23 @@ TEST(FlexibleSyntax, StdMultiSet) {
     t1.emplace("one");
     t1.emplace("two");
 
-    EXPECT_TRUE(procArchive(t1) == t1);
-    EXPECT_TRUE(procArchiveWithMaxSize(t1) == t1);
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+    EXPECT_TRUE(procBriefSyntaxWithMaxSize(t1) == t1);
 }
 
-TEST(FlexibleSyntax, StdSmartPtr) {
+TEST(BriefSyntax, StdSmartPtr) {
     std::shared_ptr<int> dataShared1(new int{4});
     std::weak_ptr<int> dataWeak1(dataShared1);
     std::unique_ptr<std::string> dataUnique1{new std::string{"hello world"}};
 
     bitsery::ext::PointerLinkingContext plctx1{};
-    BasicSerializationContext<bitsery::DefaultConfig, bitsery::ext::PointerLinkingContext> ctx;
-    ctx.createSerializer(&plctx1).archive(dataShared1, dataWeak1, dataUnique1);
+    BasicSerializationContext<bitsery::ext::PointerLinkingContext> ctx;
+    ctx.createSerializer(plctx1)(dataShared1, dataWeak1, dataUnique1);
 
     std::shared_ptr<int> resShared1{};
     std::weak_ptr<int> resWeak1{};
     std::unique_ptr<std::string> resUnique1{};
-    ctx.createDeserializer(&plctx1).archive(resShared1, resWeak1, resUnique1);
+    ctx.createDeserializer(plctx1)(resShared1, resWeak1, resUnique1);
     //clear shared state from pointer linking context
     plctx1.clearSharedState();
 
@@ -388,11 +398,38 @@ TEST(FlexibleSyntax, StdSmartPtr) {
     EXPECT_THAT(*resUnique1, Eq(*dataUnique1));
 }
 
-TEST(FlexibleSyntax, NestedTypes) {
+TEST(BriefSyntax, StdDuration) {
+    std::chrono::duration<int64_t, std::milli> t1{54654};
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+}
+
+TEST(BriefSyntax, StdTimePoint) {
+    using Duration = std::chrono::duration<double, std::milli>;
+    using TP = std::chrono::time_point<std::chrono::system_clock, Duration>;
+
+    TP data{Duration{874656.4798}};
+    EXPECT_TRUE(procBriefSyntax(data) == data);
+}
+
+#if __cplusplus > 201402L
+
+TEST(BriefSyntax, StdTuple) {
+    std::tuple<int, std::string, std::vector<char>> t1{5,"hello hello", {'A','B','C'}};
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+}
+
+TEST(BriefSyntax, StdVariant) {
+    std::variant<float, std::string, std::chrono::milliseconds> t1{std::string("hello hello")};
+    EXPECT_TRUE(procBriefSyntax(t1) == t1);
+}
+
+#endif
+
+TEST(BriefSyntax, 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));
+    EXPECT_THAT(procBriefSyntax(t1), Eq(t1));
+    EXPECT_THAT(procBriefSyntaxWithMaxSize(t1), Eq(t1));
 }

tests/data_endianness.cpp

@@ -20,10 +20,9 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
 
-
-#include <bitsery/adapter_writer.h>
-#include <bitsery/adapter_reader.h>
 #include <bitsery/ext/value_range.h>
+#include <bitsery/serializer.h>
+#include <bitsery/deserializer.h>
 #include "serialization_test_utils.h"
 #include <gmock/gmock.h>
 
@@ -38,8 +37,10 @@ constexpr EndiannessType getInverseEndianness(EndiannessType e) {
            : EndiannessType::LittleEndian;
 }
 
-struct InverseEndiannessConfig:public DefaultConfig {
-    static constexpr bitsery::EndiannessType NetworkEndianness = getInverseEndianness(DefaultConfig::NetworkEndianness);
+struct InverseEndiannessConfig {
+    static constexpr bitsery::EndiannessType Endianness = getInverseEndianness(DefaultConfig::Endianness);
+    static constexpr bool CheckDataErrors = true;
+    static constexpr bool CheckAdapterErrors = true;
 };
 
 struct IntegralTypes {
@@ -50,25 +51,25 @@ struct IntegralTypes {
     int8_t e;
 };
 
-using InverseReader = bitsery::AdapterReader<InputAdapter, InverseEndiannessConfig>;
+using InverseReader = bitsery::InputBufferAdapter<Buffer, InverseEndiannessConfig>;
 
 
 TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
     //fill initial values
     IntegralTypes src{};
-    src.a = static_cast<int64_t>(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.a = static_cast<int64_t>(0x1122334455667788u);
+    src.b = 0xBBCCDDEEu;
+    src.c = static_cast<int16_t>(0xCCDDu);
+    src.d = static_cast<uint8_t>(0xDDu);
+    src.e = static_cast<int8_t>(0xEEu);
 
     //fill expected result after swap
     IntegralTypes resInv{};
-    resInv.a = static_cast<int64_t>(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.a = static_cast<int64_t>(0x8877665544332211u);
+    resInv.b = 0xEEDDCCBBu;
+    resInv.c = static_cast<int16_t>(0xDDCCu);
+    resInv.d = static_cast<uint8_t>(0xDDu);
+    resInv.e = static_cast<int8_t>(0xEEu);
 
     //create and write to buffer
     Buffer buf{};
@@ -80,7 +81,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()}};
+    InverseReader br{buf.begin(), bw.writtenBytesCount()};
     IntegralTypes res{};
     br.readBytes<8>(res.a);
     br.readBytes<4>(res.b);
@@ -106,7 +107,7 @@ TEST(DataEndianness, WhenWrite1ByteValuesThenEndiannessIsIgnored) {
     bw.writeBuffer<1>(src, SIZE);
     bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    InverseReader br{buf.begin(), bw.writtenBytesCount()};
     br.readBuffer<1>(res, SIZE);
     //result is identical, because we write separate values, of size 1byte, that requires no swapping
     //check results
@@ -125,7 +126,7 @@ TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
     bw.writeBuffer<2>(src, SIZE);
     bw.flush();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    InverseReader br{buf.begin(), bw.writtenBytesCount()};
     br.readBuffer<2>(res, SIZE);
     //result is identical, because we write separate values, of size 1byte, that requires no swapping
     //check results
@@ -161,15 +162,15 @@ TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndiann
     //create and write to buffer
     Buffer buf{};
     Writer bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<Writer> bpw{bw};
+    bitsery::details::OutputAdapterBitPackingWrapper<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();
     //read from buffer using inverse endianness config
-    InverseReader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
-    bitsery::AdapterReaderBitPackingWrapper<InverseReader> bpr{br};
+    InverseReader br{buf.begin(), bpw.writtenBytesCount()};
+    bitsery::details::InputAdapterBitPackingWrapper<InverseReader> bpr{br};
     IntegralUnsignedTypes res{};
     bpr.readBits(res.a, aBITS);
     bpr.readBits(res.b, bBITS);

tests/data_operations.cpp

@@ -22,6 +22,8 @@
 
 
 #include <bitsery/ext/value_range.h>
+#include <bitsery/serializer.h>
+#include <bitsery/deserializer.h>
 #include <gmock/gmock.h>
 #include "serialization_test_utils.h"
 
@@ -29,8 +31,8 @@
 using testing::Eq;
 using testing::ContainerEq;
 
-using AdapterBitPackingWriter = bitsery::AdapterWriterBitPackingWrapper<Writer>;
-using AdapterBitPackingReader = bitsery::AdapterReaderBitPackingWrapper<Reader>;
+using AdapterBitPackingWriter = bitsery::details::OutputAdapterBitPackingWrapper<Writer>;
+using AdapterBitPackingReader = bitsery::details::InputAdapterBitPackingWrapper<Reader>;
 
 
 struct IntegralUnsignedTypes {
@@ -58,7 +60,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
     bpw.writeBits(std::numeric_limits<uint8_t>::max(), 8);
     bpw.flush();
 
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
+    Reader br{buf.begin(), bpw.writtenBytesCount()};
     AdapterBitPackingReader bpr{br};
     uint64_t v64{};
     uint32_t v32{};
@@ -106,7 +108,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBits) {
     auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
     EXPECT_THAT(writtenSize, Eq(bytesCount));
     //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
+    Reader br{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr{br};
 
     IntegralUnsignedTypes res{};
@@ -139,7 +141,7 @@ TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
     EXPECT_THAT(writtenSize, Eq(1));
 
     //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
+    Reader br{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr{br};
     uint16_t tmp;
     bpr.readBits(tmp,4);
@@ -150,7 +152,7 @@ TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
     EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::DataOverflow));//false
 
     //part of next byte
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
+    Reader br1{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr1{br1};
     bpr1.readBits(tmp,2);
     EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::NoError));
@@ -158,7 +160,7 @@ TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
     EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::DataOverflow));//false
 
     //bigger than byte
-    Reader br2{InputAdapter{buf.begin(), writtenSize}};
+    Reader br2{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr2{br2};
     bpr2.readBits(tmp,9);
     EXPECT_THAT(bpr2.error(), Eq(bitsery::ReaderError::DataOverflow));//false
@@ -181,7 +183,7 @@ TEST(DataBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
     bpw.flush();
 
     unsigned char tmp;
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
+    Reader br{buf.begin(), bpw.writtenBytesCount()};
     AdapterBitPackingReader bpr{br};
     bpr.readBits(tmp,2);
     EXPECT_THAT(tmp, Eq(3u));
@@ -214,14 +216,14 @@ TEST(DataBitsAndBytesOperations, AlignWritesZerosBits) {
     auto writtenSize = bpw.writtenBytesCount();
     EXPECT_THAT(writtenSize, Eq(1));
     unsigned char tmp;
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
+    Reader br1{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}};
+    Reader br2{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr2{br2};
     //read 2 bits
     bpr2.readBits(tmp,2);
@@ -266,7 +268,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBytes) {
 
     EXPECT_THAT(writtenSize, Eq(18));
     //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
+    Reader br{buf.begin(), writtenSize};
     IntegralTypes res{};
     br.readBytes<4>(res.b);
     br.readBytes<2>(res.c);
@@ -312,7 +314,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBytesWithBitPackingWrapper) {
 
     EXPECT_THAT(writtenSize, Eq(18));
     //read from buffer
-    Reader br{InputAdapter{buf.begin(), writtenSize}};
+    Reader br{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr{br};
     IntegralTypes res{};
     bpr.readBytes<4>(res.b);
@@ -343,7 +345,7 @@ TEST(DataBitsAndBytesOperations, ReadWriteFncCanAcceptSignedData) {
     bw.writeBuffer<2>(src, DATA_SIZE);
     bw.flush();
     //read from buffer
-    Reader br1{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
+    Reader br1{buf.begin(), bw.writtenBytesCount()};
     int16_t dst[DATA_SIZE]{};
     br1.readBuffer<2>(dst, DATA_SIZE);
     EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
@@ -366,7 +368,7 @@ TEST(DataBitsAndBytesOperations, ReadWriteCanWorkOnUnalignedData) {
     EXPECT_THAT(writtenSize, Eq(sizeof(src) + 1));
 
     //read from buffer
-    Reader br1{InputAdapter{buf.begin(), writtenSize}};
+    Reader br1{buf.begin(), writtenSize};
     AdapterBitPackingReader bpr1{br1};
     int16_t dst[DATA_SIZE]{};
     uint8_t tmp{};
@@ -394,7 +396,7 @@ TEST(DataBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZ
     bpw.flush();
 
     //read from buffer
-    Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
+    Reader br{buf.begin(), bpw.writtenBytesCount()};
     AdapterBitPackingReader bpr{br};
     uint8_t tmp{};
     bpr.readBits(tmp, 2);

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,137 +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 <bitsery/traits/string.h>
-#include <gmock/gmock.h>
-#include "serialization_test_utils.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

@@ -33,7 +33,7 @@ using bitsery::EndiannessType;
 template <typename BufType>
 class DataWriting:public testing::Test {
 public:
-    using TWriter = bitsery::AdapterWriter<bitsery::OutputBufferAdapter<BufType>, bitsery::DefaultConfig>;
+    using TWriter = bitsery::OutputBufferAdapter<BufType>;
     using TBuffer = BufType;
 };
 
@@ -74,7 +74,7 @@ TYPED_TEST(DataWriting, WhenWritingBitsThenMustFlushWriter) {
     using TBuffer = typename TestFixture::TBuffer;
     TBuffer buf{};
     TWriter bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
+    bitsery::details::OutputAdapterBitPackingWrapper<TWriter> bpw{bw};
     bpw.writeBits(3u, 2);
     auto writtenSize1 = bpw.writtenBytesCount();
     bpw.flush();
@@ -88,7 +88,7 @@ TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
     using TBuffer = typename TestFixture::TBuffer;
     TBuffer buf{};
     TWriter bw{buf};
-    bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
+    bitsery::details::OutputAdapterBitPackingWrapper<TWriter> bpw{bw};
     bpw.writeBits(3u, 2);
     bpw.align();
     auto writtenSize1 = bpw.writtenBytesCount();
@@ -101,7 +101,7 @@ TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
 
 TEST(DataWritingNonFixedBufferContainer, ContainerIsAlwaysResizedToCapacity) {
     NonFixedContainer buf{};
-    bitsery::AdapterWriter<bitsery::OutputBufferAdapter<NonFixedContainer>, bitsery::DefaultConfig> bw{buf};
+    bitsery::OutputBufferAdapter<NonFixedContainer> bw{buf};
     for (auto i = 0; i < 5; ++i) {
         uint32_t tmp{};
         bw.writeBytes<4>(tmp);

tests/not_default_constructible.cpp

@@ -0,0 +1,350 @@
+//MIT License
+//
+//Copyright (c) 2019 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 <forward_list>
+#include <bitsery/traits/forward_list.h>
+#include <bitsery/ext/std_set.h>
+#include <bitsery/ext/std_map.h>
+#include <bitsery/ext/pointer.h>
+#include <bitsery/ext/std_smart_ptr.h>
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+
+
+using testing::ContainerEq;
+using testing::Eq;
+
+//forward declare, for testing with std::unordered_map
+class HasherForNonDefaultConstructible;
+
+class NonDefaultConstructible {
+    int32_t i{0};
+    friend class HasherForNonDefaultConstructible;
+
+
+
+
+    friend class bitsery::Access;
+    NonDefaultConstructible() = default;
+
+    template <typename S>
+    void serialize(S& s) {
+        s.value4b(i);
+    }
+
+public:
+
+    explicit NonDefaultConstructible(int32_t v):i{v} {}
+
+    bool operator == (const NonDefaultConstructible& other) const {
+        return i == other.i;
+    }
+
+    bool operator < (const NonDefaultConstructible& other) const {
+        return i < other.i;
+    }
+};
+
+class HasherForNonDefaultConstructible {
+public:
+    size_t operator()(const NonDefaultConstructible& o) const {
+        return std::hash<int32_t>()(o.i);
+    }
+};
+
+
+
+
+TEST(DeserializeNonDefaultConstructible, Container) {
+    SerializationContext ctx{};
+    std::vector<NonDefaultConstructible> data{};
+    data.emplace_back(1);
+    data.emplace_back(2);
+    data.emplace_back(3);
+    std::vector<NonDefaultConstructible> res{};
+
+    ctx.createSerializer().container(data, 10);
+    ctx.createDeserializer().container(res, 10);
+
+    EXPECT_THAT(res, ContainerEq(data));
+}
+//this test is here, because when object is not constructible we cannot simple "resize" container
+TEST(DeserializeNonDefaultConstructible, ResultContainerShouldShrink) {
+    SerializationContext ctx{};
+    std::vector<NonDefaultConstructible> data{};
+    data.emplace_back(1);
+    std::vector<NonDefaultConstructible> res{};
+    res.emplace_back(2);
+    res.emplace_back(3);
+
+    ctx.createSerializer().container(data, 10);
+    ctx.createDeserializer().container(res, 10);
+
+    EXPECT_THAT(res, ContainerEq(data));
+}
+
+TEST(DeserializeNonDefaultConstructible, ResultStdForwardListShouldShrink) {
+    // forward list doesn't have .erase function, bet has erase_after
+    // in this case, if new size is 0 it must call clear, so we need to check two cases
+    {
+        // 1) when result should have more than 0 elements
+        SerializationContext ctx{};
+        std::forward_list<NonDefaultConstructible> data{};
+        data.push_front(NonDefaultConstructible{1});
+        std::forward_list<NonDefaultConstructible> res{};
+        res.push_front(NonDefaultConstructible{21});
+        res.push_front(NonDefaultConstructible{14});
+
+        ctx.createSerializer().container(data, 10);
+        ctx.createDeserializer().container(res, 10);
+
+        auto resIt = res.begin();
+        for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
+            EXPECT_THAT(*resIt, Eq(*it));
+        }
+        EXPECT_THAT(resIt, Eq(res.end()));
+
+    }
+    {
+        // 1) when result should have 0 elements
+        SerializationContext ctx{};
+        std::forward_list<NonDefaultConstructible> data{};
+        std::forward_list<NonDefaultConstructible> res{};
+        res.push_front(NonDefaultConstructible{1});
+        res.push_front(NonDefaultConstructible{14});
+
+        ctx.createSerializer().container(data, 10);
+        ctx.createDeserializer().container(res, 10);
+
+        EXPECT_THAT(res.begin(), Eq(res.end()));
+
+    }
+
+    {
+        // also check if correctly expands if source is bigger than destination
+        SerializationContext ctx{};
+        std::forward_list<NonDefaultConstructible> data{};
+        data.push_front(NonDefaultConstructible{1});
+        data.push_front(NonDefaultConstructible{14});
+        std::forward_list<NonDefaultConstructible> res{};
+
+        ctx.createSerializer().container(data, 10);
+        ctx.createDeserializer().container(res, 10);
+
+        auto resIt = res.begin();
+        for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
+            EXPECT_THAT(*resIt, Eq(*it));
+        }
+        EXPECT_THAT(resIt, Eq(res.end()));
+    }
+}
+
+TEST(DeserializeNonDefaultConstructible, StdSet) {
+    SerializationContext ctx{};
+    std::set<NonDefaultConstructible> data;
+    data.insert(NonDefaultConstructible{1});
+    data.insert(NonDefaultConstructible{2});
+    std::set<NonDefaultConstructible> res{};
+    data.insert(NonDefaultConstructible{3});
+
+    ctx.createSerializer().ext(data, bitsery::ext::StdSet{10});
+    ctx.createDeserializer().ext(res, bitsery::ext::StdSet{10});
+
+    EXPECT_THAT(res, ContainerEq(data));
+}
+
+TEST(DeserializeNonDefaultConstructible, StdMap) {
+    SerializationContext ctx{};
+    std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> data;
+    data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
+
+    std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> res{};
+    data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
+    data.emplace(NonDefaultConstructible{4}, NonDefaultConstructible{4});
+
+    auto& ser = ctx.createSerializer();
+    ser.ext(data, bitsery::ext::StdMap{10},[](decltype(ser)& ser, NonDefaultConstructible& key, NonDefaultConstructible& value) {
+        ser.object(key);
+        ser.object(value);
+    });
+    auto& des = ctx.createDeserializer();
+    des.ext(res, bitsery::ext::StdMap{10},[](decltype(des)& des, NonDefaultConstructible& key, NonDefaultConstructible& value) {
+        des.object(key);
+        des.object(value);
+    });
+
+    EXPECT_THAT(res, ContainerEq(data));
+}
+
+
+struct NonPolymorphicPointers {
+    NonDefaultConstructible* pp;
+    std::unique_ptr<NonDefaultConstructible> up;
+    std::shared_ptr<NonDefaultConstructible> sp;
+    std::weak_ptr<NonDefaultConstructible> wp;
+};
+
+template <typename S>
+void serialize(S& s, NonPolymorphicPointers& o) {
+    s.ext(o.pp, bitsery::ext::PointerOwner{});
+    s.ext(o.up, bitsery::ext::StdSmartPtr{});
+    s.ext(o.sp, bitsery::ext::StdSmartPtr{});
+    s.ext(o.wp, bitsery::ext::StdSmartPtr{});
+}
+
+TEST(DeserializeNonDefaultConstructible, NonPolymorphicPointerAndSmartPointer) {
+    using SerContext = BasicSerializationContext<bitsery::ext::PointerLinkingContext>;
+    SerContext ctx{};
+    NonPolymorphicPointers data{};
+    data.pp = new NonDefaultConstructible{3};
+    data.up = std::unique_ptr<NonDefaultConstructible>(new NonDefaultConstructible{54});
+    data.sp = std::shared_ptr<NonDefaultConstructible>(new NonDefaultConstructible{-481});
+    data.wp = data.sp;
+
+    NonPolymorphicPointers res{};
+    bitsery::ext::PointerLinkingContext plctx1{};
+    ctx.createSerializer(plctx1).object(data);
+    ctx.createDeserializer(plctx1).object(res);
+
+    EXPECT_THAT(*res.pp, Eq(*data.pp));
+    delete res.pp;
+    delete data.pp;
+    EXPECT_THAT(*res.up, Eq(*data.up));
+    EXPECT_THAT(*res.sp, Eq(*data.sp));
+    EXPECT_THAT(*(res.wp.lock()), Eq(*(data.wp.lock())));
+}
+
+class PolymorphicNDCBase {
+public:
+    virtual ~PolymorphicNDCBase() = 0;
+    template <typename S>
+    void serialize(S& ) {}
+};
+
+
+PolymorphicNDCBase::~PolymorphicNDCBase() = default;
+
+class PolymorphicNDC1:public PolymorphicNDCBase {
+    int8_t i{};
+    friend class bitsery::Access;
+
+    template <typename S>
+    void serialize(S& s) {
+        s.value1b(i);
+    }
+public:
+    PolymorphicNDC1() = default;
+    PolymorphicNDC1(int8_t v):i{v} {}
+    bool operator == (const PolymorphicNDC1& other) const {
+        return i == other.i;
+    }
+};
+
+class PolymorphicNDC2:public PolymorphicNDCBase {
+    uint16_t ui{};
+
+    friend class bitsery::Access;
+
+    template <typename S>
+    void serialize(S& s) {
+        s.value2b(ui);
+    }
+public:
+    PolymorphicNDC2() = default;
+    PolymorphicNDC2(uint16_t v):ui{v} {}
+    bool operator == (const PolymorphicNDC2& other) const {
+        return ui == other.ui;
+    }
+
+};
+
+
+namespace bitsery {
+    namespace ext {
+
+        template<>
+        struct PolymorphicBaseClass<PolymorphicNDCBase> : PolymorphicDerivedClasses<PolymorphicNDC1, PolymorphicNDC2> {
+        };
+    }
+}
+
+
+struct PolymorphicPointers {
+    PolymorphicNDCBase* pp;
+    std::unique_ptr<PolymorphicNDCBase> up;
+    std::shared_ptr<PolymorphicNDCBase> sp;
+    std::weak_ptr<PolymorphicNDCBase> wp;
+};
+
+template <typename S>
+void serialize(S& s, PolymorphicPointers& o) {
+    s.ext(o.pp, bitsery::ext::PointerOwner{});
+    s.ext(o.up, bitsery::ext::StdSmartPtr{});
+    s.ext(o.sp, bitsery::ext::StdSmartPtr{});
+    s.ext(o.wp, bitsery::ext::StdSmartPtr{});
+}
+
+TEST(DeserializeNonDefaultConstructible, PolymorphicPointerAndSmartPointer) {
+    using TContext = std::tuple<bitsery::ext::PointerLinkingContext, bitsery::ext::PolymorphicContext<bitsery::ext::StandardRTTI>>;
+    using SerContext = BasicSerializationContext<TContext>;
+    SerContext ctx{};
+    PolymorphicPointers data{};
+    data.pp = new PolymorphicNDC1{-4};
+    data.up = std::unique_ptr<PolymorphicNDCBase>(new PolymorphicNDC2{54});
+    data.sp = std::shared_ptr<PolymorphicNDCBase>(new PolymorphicNDC1{15});
+    data.wp = data.sp;
+
+    PolymorphicPointers res{};
+
+    TContext serCtx{};
+    TContext desCtx{};
+
+    std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
+    std::get<1>(desCtx).registerBasesList<typename SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
+
+    ctx.createSerializer(serCtx).object(data);
+    ctx.createDeserializer(desCtx).object(res);
+    auto respp = dynamic_cast<PolymorphicNDC1*>(res.pp);
+    auto resup = dynamic_cast<PolymorphicNDC2*>(res.up.get());
+    auto ressp = dynamic_cast<PolymorphicNDC1*>(res.sp.get());
+    auto reswp = dynamic_cast<PolymorphicNDC1*>(res.wp.lock().get());
+
+    auto datapp = dynamic_cast<PolymorphicNDC1*>(data.pp);
+    auto dataup = dynamic_cast<PolymorphicNDC2*>(data.up.get());
+    auto datasp = dynamic_cast<PolymorphicNDC1*>(data.sp.get());
+    auto datawp = dynamic_cast<PolymorphicNDC1*>(data.wp.lock().get());
+
+    EXPECT_THAT(respp, ::testing::Ne(nullptr));
+    EXPECT_THAT(resup, ::testing::Ne(nullptr));
+    EXPECT_THAT(ressp, ::testing::Ne(nullptr));
+    EXPECT_THAT(reswp, ::testing::Ne(nullptr));
+
+    EXPECT_THAT(*respp, Eq(*datapp));
+    delete res.pp;
+    delete data.pp;
+    EXPECT_THAT(*resup, Eq(*dataup));
+    EXPECT_THAT(*ressp, Eq(*datasp));
+    EXPECT_THAT(*reswp, Eq(*datawp));
+    std::get<0>(serCtx).clearSharedState();
+    std::get<0>(desCtx).clearSharedState();
+}

tests/serialization.cpp

@@ -0,0 +1,48 @@
+//MIT License
+//
+//Copyright (c) 2019 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;
+
+TEST(Serialization, AdapterCanBeMovedInAndOut) {
+    Buffer buf{};
+    bitsery::Serializer<Writer> ser1{buf};
+    ser1.object(MyStruct1{1, 2});
+    auto writeAdapter = std::move(ser1).adapter();
+    bitsery::Serializer<Writer> ser2(std::move(writeAdapter));
+    ser2.object(MyStruct1{3, 4});
+    auto writtenBytesCount = ser2.adapter().writtenBytesCount();
+    EXPECT_THAT(writtenBytesCount, Eq(MyStruct1::SIZE + MyStruct1::SIZE));
+
+    MyStruct1 res{};
+    bitsery::Deserializer<Reader> des1{buf.begin(), writtenBytesCount};
+    des1.object(res);
+    EXPECT_THAT(res, Eq(MyStruct1{1, 2}));
+    auto readerAdapter = std::move(des1).adapter();
+    bitsery::Deserializer<Reader> des2(std::move(readerAdapter));
+    des2.object(res);
+    EXPECT_THAT(res, Eq(MyStruct1{3, 4}));
+    EXPECT_TRUE(des2.adapter().isCompletedSuccessfully());
+}

tests/serialization_bool.cpp

@@ -26,10 +26,6 @@
 
 using testing::Eq;
 
-using Serializer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
-
-using Deserializer = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
-
 
 TEST(SerializeBooleans, BoolAsBit) {
 
@@ -39,12 +35,12 @@ TEST(SerializeBooleans, BoolAsBit) {
     bool res1;
     bool res2;
     auto& ser = ctx.createSerializer();
-    ser.enableBitPacking([&t1, &t2](Serializer& sbp) {
+    ser.enableBitPacking([&t1, &t2](SerializationContext::TSerializerBPEnabled& sbp) {
         sbp.boolValue(t1);
         sbp.boolValue(t2);
     });
     auto& des = ctx.createDeserializer();
-    des.enableBitPacking([&res1, &res2](Deserializer& sbp) {
+    des.enableBitPacking([&res1, &res2](SerializationContext::TDeserializerBPEnabled& sbp) {
         sbp.boolValue(res1);
         sbp.boolValue(res2);
     });
@@ -71,3 +67,17 @@ TEST(SerializeBooleans, BoolAsByte) {
     EXPECT_THAT(res2, Eq(t2));
     EXPECT_THAT(ctx.getBufferSize(), Eq(2));
 }
+
+TEST(SerializeBooleans, WhenReadingBoolByteReadsMoreThanOneThenInvalidDataErrorAndResultIsFalse) {
+    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.des->adapter().error(), Eq(bitsery::ReaderError::InvalidData));
+}

tests/serialization_container.cpp

@@ -64,6 +64,13 @@ std::list<MyStruct2> getFilledContainer<std::list<MyStruct2>>() {
     };
 }
 
+struct EmptyFtor {
+    template <typename S, typename T>
+    void operator() (S& , T& ) {
+
+    }
+};
+
 /*
  * start testing session
  */
@@ -107,11 +114,11 @@ TYPED_TEST(SerializeContainerDynamicSizeArthmeticTypes, CustomFunctionIncrements
     using TValue = typename TestFixture::TValue;
 
     auto& ser = ctx.createSerializer();
-    ser.container(this->src, 1000, [&ser](TValue& v) {
+    ser.container(this->src, 1000, [](decltype(ser)& ser, TValue& v) {
         ser.template value<sizeof(v)>(v);
     });
     auto& des = ctx.createDeserializer();
-    des.container(this->res, 1000, [&des](TValue &v) {
+    des.container(this->res, 1000, [](decltype(des)& des, TValue &v) {
         des.template value<sizeof(v)>(v);
         //increment by 1 after reading
         v++;
@@ -161,9 +168,8 @@ TYPED_TEST(SerializeContainerDynamicSizeCompositeTypes, CustomFunctionThatDoNoth
     SerializationContext ctx{};
     using TValue = typename TestFixture::TValue;
 
-    auto emptyFnc = [](TValue &) {};
-    ctx.createSerializer().container(this->src, 1000, emptyFnc);
-    ctx.createDeserializer().container(this->res, 1000, emptyFnc);
+    ctx.createSerializer().container(this->src, 1000, EmptyFtor{});
+    ctx.createDeserializer().container(this->res, 1000, EmptyFtor{});
 
     EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(this->src.size())));
 }
@@ -232,13 +238,13 @@ TYPED_TEST(SerializeContainerFixedSizeCompositeTypes, CustomFunctionThatSerializ
 
     SerializationContext ctx{};
     auto& ser = ctx.createSerializer();
-    ser.container(src, [&ser](TValue &v) {
+    ser.container(src, [](decltype(ser)& ser, TValue &v) {
         char tmp{};
         ser.object(v);
         ser.value1b(tmp);
     });
     auto& des = ctx.createDeserializer();
-    des.container(res, [&des](TValue &v) {
+    des.container(res, [](decltype(des)& des, TValue &v) {
         char tmp{};
         des.object(v);
         des.value1b(tmp);
@@ -253,12 +259,11 @@ 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);
+    ctx.createSerializer().container(src, std::numeric_limits<size_t>::max(), EmptyFtor{});
+    ctx.createDeserializer().container(res, std::numeric_limits<size_t>::max(), EmptyFtor{});
 
     EXPECT_THAT(res.size(), Eq(src.size()));
     EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(src.size())));

tests/serialization_context.cpp

@@ -26,108 +26,83 @@
 
 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 bitsery::DefaultConfig;
 
 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, WhenContextIsNotTupleThenReturnThisContext) {
+    SingleTypeContext ctx{54};
+    BasicSerializationContext<SingleTypeContext> c1;
+    auto& ser1 = c1.createSerializer(ctx);
 
+    EXPECT_THAT(ser1.context<SingleTypeContext>(), Eq(ctx));
 }
 
-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, WhenContextIsTupleThenReturnsTupleElements) {
+
+    MultipleTypesContext ctx{5, 798.654, 'F'};
+    BasicSerializationContext<MultipleTypesContext> c1;
+    auto& ser1 = c1.createSerializer(ctx);
+
+    EXPECT_THAT(ser1.context<int>(), std::get<0>(ctx));
+    EXPECT_THAT(ser1.context<float>(), std::get<1>(ctx));
+    EXPECT_THAT(ser1.context<char>(), std::get<2>(ctx));
 }
 
-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());
+TEST(SerializationContext, WhenContextDoesntExistsThenContextOrNullReturnsNull) {
+    SingleTypeContext ctx1= 32;
+    BasicSerializationContext<SingleTypeContext> c1;
+    auto& ser = c1.createSerializer(ctx1);
     EXPECT_THAT(ser.contextOrNull<char>(), ::testing::IsNull());
+    EXPECT_THAT(ser.contextOrNull<int>(), ::testing::NotNull());
+    *ser.contextOrNull<int>() = 2;
+    EXPECT_THAT(ctx1, Eq(2));
 
-    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());
+    MultipleTypesContext ctx2{5, 798.654, 'F'};
+    BasicSerializationContext<MultipleTypesContext> c2;
+    auto& des = c2.createDeserializer(ctx2);
+    EXPECT_THAT(des.contextOrNull<double>(), ::testing::IsNull());
+    EXPECT_THAT(des.contextOrNull<int>(), ::testing::NotNull());
+    EXPECT_THAT(*des.contextOrNull<char>(), Eq('F'));
+    EXPECT_THAT(*des.contextOrNull<int>(), Eq(5));
+}
+
+struct Base { int value{}; };
+struct Derived: Base{};
+
+TEST(SerializationContext, ContextWillTryToConvertIfTypeIsConvertible) {
+    Derived ctx1{};
+    BasicSerializationContext<Derived> c1;
+    auto& ser = c1.createSerializer(ctx1);
+    EXPECT_THAT(ser.contextOrNull<Derived>(), ::testing::NotNull());
+    EXPECT_THAT(ser.contextOrNull<Base>(), ::testing::NotNull());
+    ser.context<Derived>();
+    ser.context<Base>();
+}
+
+TEST(SerializationContext, WhenMultipleConvertibleTypesExistsThenFirstMatchIsTaken) {
+    {
+        using CTX1 = std::tuple<Base, int, Derived>;
+        CTX1 ctx1{};
+        std::get<0>(ctx1).value = 1;
+        std::get<2>(ctx1).value = 2;
+        BasicSerializationContext<CTX1> c1;
+        auto& ser = c1.createSerializer(ctx1);
+        EXPECT_THAT(ser.context<Derived>().value, Eq(std::get<2>(ctx1).value));
+        EXPECT_THAT(ser.context<Base>().value, Eq(std::get<0>(ctx1).value));
+    }
+
+    {
+        using CTX2 = std::tuple<float, Derived, Base>;
+        CTX2 ctx2{};
+        std::get<1>(ctx2).value = 1;
+        std::get<2>(ctx2).value = 2;
+        BasicSerializationContext<CTX2> c2;
+        auto& des = c2.createSerializer(ctx2);
+
+        EXPECT_THAT(des.context<Derived>().value, Eq(std::get<1>(ctx2).value));
+        //Base will not be accessable in this case, because Derived is first valid match
+        EXPECT_THAT(des.context<Base>().value, Eq(std::get<1>(ctx2).value));
+    }
 }

tests/serialization_ext_compact_value.cpp

@@ -26,7 +26,6 @@
 #include "serialization_test_utils.h"
 
 #include <bitsery/traits/array.h>
-#include <iostream>
 #include <bitset>
 #include <chrono>
 
@@ -52,21 +51,28 @@ TValue getValue(bool isPositive, size_t significantBits) {
 }
 
 // helper function, that serialize and return deserialized value
-template <typename TSerContext, typename TValue>
+template <typename TConfig, typename TValue>
 std::pair<TValue, size_t> serializeAndGetDeserialized(TValue data) {
-    TSerContext ctx;
-    TValue res{};
-    ctx.createSerializer().template ext<sizeof(TValue)>(data, CompactValue{});
-    ctx.createDeserializer().template ext<sizeof(TValue)>(res, CompactValue{});
-    return {res, ctx.getBufferSize()};
+    Buffer buf{};
+    bitsery::Serializer<bitsery::OutputBufferAdapter<Buffer, TConfig>> ser{buf};
+    ser.template ext<sizeof(TValue)>(data, CompactValue{});
+
+    bitsery::Deserializer<bitsery::InputBufferAdapter<Buffer, TConfig>> des{buf.begin(), ser.adapter().writtenBytesCount()};
+    TValue res;
+    des.template ext<sizeof(TValue)>(res, CompactValue{});
+    return {res, ser.adapter().writtenBytesCount()};
 }
 
-struct LittleEndianConfig: public bitsery::DefaultConfig {
-    static constexpr EndiannessType NetworkEndianness = EndiannessType::LittleEndian;
+struct LittleEndianConfig {
+    static constexpr EndiannessType Endianness = EndiannessType::LittleEndian;
+    static constexpr bool CheckDataErrors = true;
+    static constexpr bool CheckAdapterErrors = true;
 };
 
-struct BigEndianConfig: public bitsery::DefaultConfig {
-    static constexpr EndiannessType NetworkEndianness = EndiannessType::BigEndian;
+struct BigEndianConfig {
+    static constexpr EndiannessType Endianness = EndiannessType::BigEndian;
+    static constexpr bool CheckDataErrors = true;
+    static constexpr bool CheckAdapterErrors = true;
 };
 
 template <typename TValue, bool isPositiveNr, typename TConfig>
@@ -121,7 +127,7 @@ TYPED_TEST(SerializeExtensionCompactValueCorrectness, TestDifferentSizeValues) {
 
     for (auto i = 0u; i < bitsery::details::BitsSize<TValue>::value + 1; ++i) {
         auto data = getValue<TValue>(tc.isPositive, i);
-        auto res = serializeAndGetDeserialized<BasicSerializationContext<typename TCase::Config, void>>(data);
+        auto res = serializeAndGetDeserialized<typename TCase::Config>(data);
         EXPECT_THAT(res.first, Eq(data));
     }
 }
@@ -203,7 +209,7 @@ TYPED_TEST(SerializeExtensionCompactValueRequiredBytes, Test) {
     using TValue = typename TCase::Value;
     TCase tc{};
     TValue data = getValue<TValue>(tc.isPositive, tc.fillBits);
-    auto res = serializeAndGetDeserialized<SerializationContext>(data);
+    auto res = serializeAndGetDeserialized<bitsery::DefaultConfig>(data);
     EXPECT_THAT(res.first, Eq(data));
     EXPECT_THAT(res.second, tc.bytesCount);
 }
@@ -220,22 +226,19 @@ TEST(SerializeExtensionCompactValueEnum, TestEnums) {
     auto d1 = b1En::E;
     auto d2 = b8En::B;
     auto d3 = b8En::F;
-    EXPECT_THAT(serializeAndGetDeserialized<SerializationContext>(d1).first, Eq(d1));
-    EXPECT_THAT(serializeAndGetDeserialized<SerializationContext>(d2).first, Eq(d2));
-    EXPECT_THAT(serializeAndGetDeserialized<SerializationContext>(d3).first, Eq(d3));
+    EXPECT_THAT(serializeAndGetDeserialized<bitsery::DefaultConfig>(d1).first, Eq(d1));
+    EXPECT_THAT(serializeAndGetDeserialized<bitsery::DefaultConfig>(d2).first, Eq(d2));
+    EXPECT_THAT(serializeAndGetDeserialized<bitsery::DefaultConfig>(d3).first, Eq(d3));
 }
 
 TEST(SerializeExtensionCompactValueAsObjectDeserializeOverflow, TestEnums) {
     SerializationContext ctx;
     auto data = getValue<uint32_t >(true, 17);
     uint16_t res{};
-    auto& ser = ctx.createSerializer();
-    ser.ext(data, CompactValueAsObject{});
-    auto& des = ctx.createDeserializer();
-    des.ext(res, CompactValueAsObject{});
-    auto& rd = bitsery::AdapterAccess::getReader(des);
+    ctx.createSerializer().ext(data, CompactValueAsObject{});
+    ctx.createDeserializer().ext(res, CompactValueAsObject{});
     EXPECT_THAT(data, ::testing::Ne(res));
-    EXPECT_THAT(rd.error(), Eq(bitsery::ReaderError::DataOverflow));
+    EXPECT_THAT(ctx.des->adapter().error(), Eq(bitsery::ReaderError::InvalidData));
 }
 
 

tests/serialization_ext_entropy.cpp

@@ -31,8 +31,8 @@ using namespace testing;
 
 using bitsery::ext::Entropy;
 
-using BPSer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
-using BPDes = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
+using BPSer = SerializationContext::TSerializerBPEnabled;
+using BPDes = SerializationContext::TDeserializerBPEnabled;
 
 
 TEST(SerializeExtensionEntropy, WhenEntropyEncodedThenOnlyWriteIndexUsingMinRequiredBits) {
@@ -128,7 +128,7 @@ TEST(SerializeExtensionEntropy, CustomFunctionNotEntropyEncodedWithNoAlignBefore
     SerializationContext ctx;
     ctx.createSerializer().enableBitPacking([&v, &values, &rangeForValue](BPSer& ser){
         //lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
-        auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
+        auto serLambda = [&rangeForValue](BPSer& ser, MyStruct1& data) {
             ser.ext(data.i1, rangeForValue);
             ser.ext(data.i2, rangeForValue);
         };
@@ -136,7 +136,7 @@ TEST(SerializeExtensionEntropy, CustomFunctionNotEntropyEncodedWithNoAlignBefore
     });
 
     ctx.createDeserializer().enableBitPacking([&res, &values, &rangeForValue](BPDes& des) {
-        auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
+        auto desLambda = [&rangeForValue](BPDes& des, MyStruct1& data) {
             des.ext(data.i1, rangeForValue);
             des.ext(data.i2, rangeForValue);
         };
@@ -161,14 +161,14 @@ TEST(SerializeExtensionEntropy, CustomFunctionNotEntropyEncodedWithAlignBeforeDa
     SerializationContext ctx;
     ctx.createSerializer().enableBitPacking([&v, &values, &rangeForValue](BPSer& ser){
         //lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
-        auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
+        auto serLambda = [&rangeForValue](BPSer& ser, MyStruct1& data) {
             ser.ext(data.i1, rangeForValue);
             ser.ext(data.i2, rangeForValue);
         };
         ser.ext(v, Entropy<std::vector<MyStruct1>>(values, true), serLambda);
     });
     ctx.createDeserializer().enableBitPacking([&res, &values, &rangeForValue](BPDes& des) {
-        auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
+        auto desLambda = [&rangeForValue](BPDes& des, MyStruct1& data) {
             des.ext(data.i1, rangeForValue);
             des.ext(data.i2, rangeForValue);
         };
@@ -189,10 +189,10 @@ TEST(SerializeExtensionEntropy, WhenEntropyEncodedThenCustomFunctionNotInvoked)
 
     SerializationContext ctx;
     ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
-        ser.ext(v, Entropy<std::list<MyStruct1>>{values}, [](MyStruct1& ) {});
+        ser.ext(v, Entropy<std::list<MyStruct1>>{values}, [](BPSer& ,MyStruct1& ) {});
     });
     ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
-        des.ext(res, Entropy<std::list<MyStruct1>>{values}, []( MyStruct1& ) {});
+        des.ext(res, Entropy<std::list<MyStruct1>>{values}, [](BPDes& , MyStruct1& ) {});
     });
 
     EXPECT_THAT(res, Eq(v));