visual studio variadic templates issues

input buffer adapter accepts const buffer
non default constructible types
2026-06-19 05:39:03 +00:00 · 2019-01-16 11:27:56 +02:00 · 2019-01-10 20:48:03 +02:00 · 2019-01-10 19:08:15 +02:00 · 2019-01-08 16:00:02 +02:00 · 2019-01-08 15:08:27 +02:00
52 changed files with 1232 additions and 239 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 .idea/
 .vs/
 build/
-cmake-build-debug/
+cmake-build-*
 CTestConfig.cmake
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,65 @@
+# [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
+* new extensions **CompactValue** and **CompactValueAsObject**, stores integral values in less space if possible. This is useful when you're working with mostly small values, that in rare cases can be large.
+E.g. `int64_t money = 8000;` will only use 2 bytes, instead of 8. **CompactValueAsObject** allows to use `ext()` overload, without specifying size of underlying type and sets BUFFER_OVERFLOW error if value doesn't fit in underlying type during deserialization.
+
+### Improvements
+* improved **PolymorphicContext**, allows to extend already registered hierarchy in one translation unit, using different type other than `PolymorphicBaseClass` to avoid symbol collision between translation units or libraries.
+`registerBasesList` was modified, so that it could accept user defined type (instead of `PolymorphicBaseClass`) that is used to declare hierarchy, by default it is `PolymorphicBaseClass`.
+This introduced breaking change, for those who used this syntax (`registerBasesList<MySerializer, Shape>({})`) during registration.
+It is encouraged to define helper type, that could be used for registering hierarchy for serialization and deserialization [example](examples/smart_pointers_with_polymorphism.cpp).
+`This is only relevant then you want to use **PolymorphicContext** between different translation units or libraries`.
+```cpp
+//libA
+namespace bitsery {
+    namespace ext {
+        template<>
+        struct PolymorphicBaseClass<Shape> : PolymorphicDerivedClasses<Circle, Rectangle> {};
+    }
+}
+using MyPolymorphicClassesForRegistering = bitsery::ext::PolymorphicClassesList<Shape>;
+...
+    ctx.registerBasesList<MySerializer>(MyPolymorphicClassesForRegistering{}).
+
+//otherLib
+struct MySquare: Shape {...}
+//now it must define different type (exactly the same as PolymorphicBaseClass) to declare hierarchy
+template<typename TBase>
+struct MyHierarchy {
+    using Childs = PolymorphicClassesList<>;
+};
+
+template <>
+struct MyHierarchy<Shape>: bitsery::ext::bitsery::ext::PolymorphicClassesList<MySquare> {};
+...
+//notice that we pass MyHierarchy as second argument
+    ctx.registerBasesList<MySerializer, MyHierarchy>(MyPolymorphicClassesForRegistering{}).
+```
+* **PolymorphicContext** also get optional method `registerSingleBaseBranch`, that allows manually register hierarchies, this might be more convenient when using you need to register in different translation units (or libraries), but it is error-prone.
+
 # [4.3.0](https://github.com/fraillt/bitsery/compare/v4.2.1...v4.3.0) (2018-08-23)

 ### Features
@@ -132,7 +194,7 @@ Be careful when using deserializing untrusted data and make sure to enforce fund
 ### Features

 * refactored interface, now works with C++11 compiler.
-* new new extension **Growable**, that allows to have forward/backward compatability within this functions serialization flow. It only allows to append new data at the end of to existing flow without breaking old consumers.
+* new extension **Growable**, that allows to have forward/backward compatability within this functions serialization flow. It only allows to append new data at the end of to existing flow without breaking old consumers.
  * old consumer: correctly read old interfce and ignore new data.
  * new consumer: get defaults (zero values) for new fields, when reading old data.
 * added new extension for associative *map* containers **ContainerMap**.
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.1)
 project(bitsery
        LANGUAGES CXX
-        VERSION 4.3.0)
+        VERSION 4.5.1)

 #======== build options ===================================
 option(BITSERY_BUILD_EXAMPLES "Build examples" OFF)
--- a/CONTRIBUTING.md
+++ b/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.
--- a/doc/README.md
+++ b/doc/README.md
@@ -28,6 +28,8 @@ Core Serializer/Deserializer functions (alphabetical order):

 Serializer/Deserializer extensions via `ext` method (alphabetical order):
 * `BaseClass` (4.2.0)
+* `CompactValue` (4.4.0)
+* `CompactValueAsObject` (4.4.0)
 * `Entropy` (3.0.0)
 * `Growable` (3.0.0)
 * `PointerOwner` (4.1.0)
--- a/examples/inheritance.cpp
+++ b/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.
 //

--- a/examples/non_default_constructible.cpp
+++ b/examples/non_default_constructible.cpp
@@ -0,0 +1,65 @@
+//
+// 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 OutputAdapter = OutputBufferAdapter<Buffer>;
+using InputAdapter = InputBufferAdapter<Buffer>;
+
+int main() {
+
+    //initialize our data
+    std::vector<MyData> data{};
+    data.emplace_back(145.4f, 84.48f);
+    std::vector<MyData> res{};
+
+    //we cant use quick (de)serialization helper methods, because we ant to serialize container directly
+    //create buffer
+    Buffer buffer{};
+
+    //create and serialize container, and get written bytes count
+    Serializer<OutputAdapter> ser{OutputAdapter{buffer}};
+    ser.container(data, 10);
+    auto writtenBytes = AdapterAccess::getWriter(ser).writtenBytesCount();
+
+    //create and deserialize container
+    Deserializer<InputAdapter> des{InputAdapter{buffer.begin(), writtenBytes}};
+    des.container(res, 10);
+
+    //check if everything went ok
+    auto& reader = AdapterAccess::getReader(des);
+    assert(reader.error() == ReaderError::NoError && reader.isCompletedSuccessfully());
+    assert(res == data);
+}
+
--- a/examples/smart_pointers_with_polymorphism.cpp
+++ b/examples/smart_pointers_with_polymorphism.cpp
@@ -27,7 +27,7 @@ struct Color {
    float r{}, g{}, b{};
    bool operator == (const Color& o) const {
        return std::tie(r, g, b) ==
-               std::tie(o.r, o.g, b);
+               std::tie(o.r, o.g, o.b);
    }

 };
@@ -177,6 +177,11 @@ namespace bitsery {
    }
 }

+// convenient type that stores all our types, so that we could easily register and
+// also it automatically ensures, that classes is registered in the same order for serialization and deserialization
+using MyPolymorphicClassesForRegistering = bitsery::ext::PolymorphicClassesList<Shape>;
+
+
 //use bitsery namespace for convenience
 using namespace bitsery;

@@ -228,13 +233,13 @@ int main() {
    Buffer buffer{};
    size_t writtenSize{};
    {
-        TContext ctx{};
-        MySerializer ser{OutputAdapter{buffer}, &ctx};
        //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
-        std::get<1>(ctx).registerBasesList(ser, ext::PolymorphicClassesList<Shape>{});
+        TContext ctx{};
+        std::get<1>(ctx).registerBasesList<MySerializer>(MyPolymorphicClassesForRegistering{});
        //serialize our data
+        MySerializer ser{OutputAdapter{buffer}, &ctx};
        ser.object(data);
        auto &w = AdapterAccess::getWriter(ser);
        w.flush();
@@ -248,10 +253,9 @@ int main() {
    SomeShapes res{};
    {
        TContext ctx{};
-        MyDeserializer des{InputAdapter{buffer.begin(), writtenSize}, &ctx};
-        //same as in serialization
-        std::get<1>(ctx).registerBasesList(des, ext::PolymorphicClassesList<Shape>{});
+        std::get<1>(ctx).registerBasesList<MyDeserializer>(MyPolymorphicClassesForRegistering{});
        //serialize our data
+        MyDeserializer des{InputAdapter{buffer.begin(), writtenSize}, &ctx};
        des.object(res);
        auto &r = AdapterAccess::getReader(des);
        //check if everything went find
--- a/include/bitsery/adapter/buffer.h
+++ b/include/bitsery/adapter/buffer.h
@@ -31,9 +31,16 @@ namespace bitsery {
    //base class that stores container iterators, and is required for session support (for reading sessions data)
    template<typename Buffer>
    class BufferIterators {
-    protected:
-        using TIterator = typename traits::BufferAdapterTraits<Buffer>::TIterator;
+        static constexpr bool isConstBuffer = std::is_const<Buffer>::value;
+        using BuffNonConst = typename std::remove_const<Buffer>::type;

+    protected:
+
+        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},
                  endIt{end} {
@@ -48,16 +55,15 @@ namespace bitsery {
    template<typename Buffer>
    class InputBufferAdapter : public BufferIterators<Buffer> {
    public:
-
        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) {
        }

        InputBufferAdapter(TIterator begin, size_t size)
@@ -104,13 +110,13 @@ namespace bitsery {
    public:

        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");

-        UnsafeInputBufferAdapter(TIterator begin, TIterator end) : BufferIterators<Buffer>(begin, end) {
+        UnsafeInputBufferAdapter(TIterator beginIt, TIterator endIt) : BufferIterators<Buffer>(beginIt, endIt) {
        }

        UnsafeInputBufferAdapter(TIterator begin, size_t size)
--- a/include/bitsery/adapter/stream.h
+++ b/include/bitsery/adapter/stream.h
@@ -20,7 +20,6 @@
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.

-
 #ifndef BITSERY_ADAPTER_STREAM_H
 #define BITSERY_ADAPTER_STREAM_H

@@ -28,7 +27,6 @@
 #include "../traits/array.h"
 #include <ios>

-
 namespace bitsery {

    template <typename TChar, typename CharTraits>
@@ -40,11 +38,6 @@ namespace bitsery {
        BasicInputStreamAdapter(std::basic_ios<TChar, CharTraits>& istream)
                :_ios{std::addressof(istream)} {}

-        template <typename T>
-        void read(T& data) {
-            read(reinterpret_cast<TValue*>(&data), sizeof(T));
-        }
-
        void read(TValue* data, size_t size) {
            if (static_cast<size_t>(_ios->rdbuf()->sgetn( data , size )) != size) {
                *data = {};
@@ -85,11 +78,6 @@ namespace bitsery {
        BasicOutputStreamAdapter(std::basic_ios<TChar, CharTraits>& ostream)
                :_ios{std::addressof(ostream)} {}

-        template <typename T>
-        void write(const T& data) {
-            write(reinterpret_cast<const TValue*>(&data), sizeof(T));
-        }
-
        void write(const TValue* data, size_t size) {
            //for optimization
            _ios->rdbuf()->sputn( data , size );
@@ -159,28 +147,6 @@ namespace bitsery {

        ~BasicBufferedOutputStreamAdapter() = default;

-        template <typename T>
-        void write(const T& data) {
-            auto tmp = _outIt;
-
-#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
-            using TDistance = typename std::iterator_traits<BufferIt>::difference_type;
-            if (std::distance(_outIt , std::end(_buf)) >= static_cast<TDistance>(size)) {
-                *reinterpret_cast<T*>(std::addressof(*tmp)) = data;
-                _outIt += sizeof(T);
-#else
-            _outIt += sizeof(T);
-            if (std::distance(_outIt , std::end(_buf)) >= 0) {
-                *reinterpret_cast<T*>(std::addressof(*tmp)) = data;
-#endif
-            } else {
-                //when buffer is full write out to stream
-                _outIt = std::begin(_buf);
-                _adapter.write(std::addressof(*_outIt), static_cast<size_t>(std::distance(_outIt, tmp)));
-                _adapter.write(reinterpret_cast<const TValue*>(&data), sizeof(T));
-            }
-        }
-
        void write(const TValue* data, size_t size) {
            auto tmp = _outIt;

--- a/include/bitsery/adapter_reader.h
+++ b/include/bitsery/adapter_reader.h
@@ -240,7 +240,7 @@ namespace bitsery {
            auto bitsLeft = size;
            T res{};
            while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, details::BitsSize<UnsignedValue>::value);
+                auto bits = (std::min)(bitsLeft, details::BitsSize<UnsignedValue>::value);
                if (m_scratchBits < bits) {
                    UnsignedValue tmp;
                    _reader.template readBytes<sizeof(UnsignedValue), UnsignedValue>(tmp);
--- a/include/bitsery/adapter_writer.h
+++ b/include/bitsery/adapter_writer.h
@@ -295,7 +295,7 @@ namespace bitsery {
            auto value = v;
            auto bitsLeft = size;
            while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, valueSize);
+                auto bits = (std::min)(bitsLeft, valueSize);
                _scratch |= static_cast<ScratchType>( value ) << _scratchBits;
                _scratchBits += bits;
                if (_scratchBits >= valueSize) {
@@ -324,7 +324,7 @@ namespace bitsery {
            }
        }

-        const UnsignedType _MASK = std::numeric_limits<UnsignedType>::max();
+        const UnsignedType _MASK = (std::numeric_limits<UnsignedType>::max)();
        ScratchType _scratch{};
        size_t _scratchBits{};
        TWriter& _writer;
--- a/include/bitsery/bitsery.h
+++ b/include/bitsery/bitsery.h
@@ -25,8 +25,8 @@
 #define BITSERY_BITSERY_H

 #define BITSERY_MAJOR_VERSION 4
-#define BITSERY_MINOR_VERSION 3
-#define BITSERY_PATCH_VERSION 0
+#define BITSERY_MINOR_VERSION 5
+#define BITSERY_PATCH_VERSION 1

 #define BITSERY_QUOTE_MACRO(name) #name
 #define BITSERY_BUILD_VERSION_STR(major,minor, patch) \
--- a/include/bitsery/details/adapter_common.h
+++ b/include/bitsery/details/adapter_common.h
@@ -29,6 +29,7 @@
 #include <vector>
 #include <stack>
 #include <cstring>
+#include <climits>
 #include "adapter_utils.h"
 #include "not_defined_type.h"

@@ -40,7 +41,7 @@ namespace bitsery {

        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");
        };

        //add swap functions to class, to avoid compilation warning about unused functions
--- a/include/bitsery/details/not_defined_type.h
+++ b/include/bitsery/details/not_defined_type.h
@@ -56,7 +56,7 @@ namespace bitsery {
            int& operator*() {
                return data;
            }
-            int data;
+            int data{};
        };

        template <typename T>
--- a/include/bitsery/details/serialization_common.h
+++ b/include/bitsery/details/serialization_common.h
@@ -32,17 +32,29 @@

 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* createInHeap() {
+            return new T{};
+        }
+
    };

    //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>
@@ -56,7 +68,7 @@ namespace bitsery {
    };


-    //serializer/deserializer, does not public interface to get underlying writer/reader
+    //serializer/deserializer, does not have 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.
@@ -173,12 +185,12 @@ namespace bitsery {
 #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,
@@ -312,13 +324,13 @@ namespace bitsery {
        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.");
+            static_assert(HasType<TCast, Args...>::value, "Invalid context cast. Context type doesn't exists.\nSome functionality requires (de)seserializer to have specific context.");
            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.");
+            static_assert(std::is_convertible<TContext *, TCast *>::value, "Invalid context cast. Context type doesn't exists.\nSome functionality requires (de)seserializer to have specific context.");
            return static_cast<TCast *>(ctx);
        }

--- a/include/bitsery/ext/compact_value.h
+++ b/include/bitsery/ext/compact_value.h
@@ -0,0 +1,176 @@
+//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_COMPACT_VALUE_H
+#define BITSERY_EXT_COMPACT_VALUE_H
+
+#include "../details/serialization_common.h"
+#include "../details/adapter_common.h"
+#include <cassert>
+
+namespace bitsery {
+
+    namespace details {
+
+        template <bool CheckOverflow>
+        class CompactValueImpl {
+        public:
+
+            template<typename Ser, typename Writer, typename T, typename Fnc>
+            void serialize(Ser &s, Writer &writer, 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>{});
+            }
+
+            template<typename Des, typename Reader, typename T, typename Fnc>
+            void deserialize(Des &d, Reader &reader, 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>{});
+            }
+
+        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 Des, typename Reader, typename T>
+            void deserializeImpl(Des &d, Reader &, T &v, std::false_type) const {
+                d.value1b(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 {
+                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 {
+                using TUnsigned = SameSizeUnsigned<T>;
+                TUnsigned res{};
+                readBytes(reader, res);
+                v = zigZagDecode<T>(res, std::is_signed<typename IntegralFromFundamental<T>::TValue>{});
+            }
+
+            // zigzag encode signed types
+            template<typename T>
+            const SameSizeUnsigned<T> &zigZagEncode(const T &v, std::false_type) const {
+                return v;
+            }
+
+            template<typename TResult, typename TUnsigned>
+            const TResult &zigZagDecode(const TUnsigned &v, std::false_type) const{
+                return v;
+            }
+
+            template<typename T>
+            SameSizeUnsigned<T> zigZagEncode(const T &v, std::true_type) const {
+                return (v << 1) ^ (v >> (BitsSize<T>::value - 1));
+            }
+
+            template<typename TResult, typename TUnsigned>
+            TResult zigZagDecode(TUnsigned v, std::true_type) const {
+                return (v >> 1) ^ (~(v & 1) + 1); // same as -(v & 1), but no warning on VisualStudio
+            }
+
+            // write/read bytes one by one
+            template<typename Writer, typename T>
+            void writeBytes(Writer &w, const T &v) const {
+                auto val = v;
+                while(val > 0x7Fu) {
+                    w.template writeBytes<1>(static_cast<uint8_t>(val | 0x80u));
+                    val >>=7u;
+                }
+                w.template writeBytes<1>(static_cast<uint8_t>(val));
+            }
+
+            template<typename Reader, typename T>
+            void readBytes(Reader &r, T &v) const {
+                constexpr auto TBITS = sizeof(T)*8;
+                uint8_t b1{0x80u};
+                auto i = 0u;
+                for (;i < TBITS && b1 > 0x7Fu; i +=7u) {
+                    r.template readBytes<1>(b1);
+                    v += static_cast<T>(b1 & 0x7Fu) << i;
+                }
+                checkReadOverflow<Reader, T>(r, i, b1, std::integral_constant<bool, CheckOverflow>{});
+            }
+            template <typename Reader, typename T>
+            void checkReadOverflow(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);
+                }
+            }
+
+            template <typename Reader, typename T>
+            void checkReadOverflow(Reader &, unsigned , uint8_t , std::false_type) const {
+
+            }
+
+        };
+
+    }
+
+    namespace ext {
+
+        // this type will use value overload, and do not check if type is sufficiently large during deserialization
+        class CompactValue: public details::CompactValueImpl<false> {};
+
+        // this type will enable object overload, and set DataOverflow if value doesn't fit in type, during deserialization
+        class CompactValueAsObject: public details::CompactValueImpl<true> {};
+
+    }
+
+    namespace traits {
+        template<typename T>
+        struct ExtensionTraits<ext::CompactValue, T> {
+            using TValue = T;
+            static constexpr bool SupportValueOverload = true;
+            // disable object overload, because we don't have implemented serialization function for fundamental types
+            static constexpr bool SupportObjectOverload = false;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+        template<typename T>
+        struct ExtensionTraits<ext::CompactValueAsObject, T> {
+            // use dummy implemenations for value and object overload
+            using TValue = void;
+            // only enable object overload
+            static constexpr bool SupportValueOverload = false;
+            static constexpr bool SupportObjectOverload = true;
+            static constexpr bool SupportLambdaOverload = false;
+        };
+
+    }
+
+}
+
+
+#endif //BITSERY_EXT_COMPACT_VALUE_H
--- a/include/bitsery/ext/std_map.h
+++ b/include/bitsery/ext/std_map.h
@@ -25,6 +25,9 @@

 #include "../traits/core/traits.h"
 #include "../details/adapter_utils.h"
+#include "../details/serialization_common.h"
+//we need this, so we could reserve for non ordered map
+#include <unordered_map>

 namespace bitsery {
    namespace ext {
@@ -53,17 +56,30 @@ namespace bitsery {

                size_t size{};
                details::readSize(reader, size, _maxSize);
-                auto hint = obj.begin();
                obj.clear();
+                reserve(obj, size);

+                auto hint = obj.begin();
                for (auto i = 0u; i < size; ++i) {
-                    TKey key;
-                    TValue value;
+                    auto key{bitsery::Access::create<TKey>()};
+                    auto value{bitsery::Access::create<TValue>()};
                    fnc(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;
        };
    }
--- a/include/bitsery/ext/std_optional.h
+++ b/include/bitsery/ext/std_optional.h
@@ -34,6 +34,7 @@
 //}
 #include <type_traits>
 #include "../traits/core/traits.h"
+#include "../details/serialization_common.h"

 namespace bitsery {
    namespace ext {
@@ -54,8 +55,7 @@ namespace bitsery {
                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 {
@@ -75,7 +75,7 @@ namespace bitsery {
                if (_alignBeforeData)
                    des.align();
                if (exists) {
-                    typename T::value_type tmp{};
+                    auto tmp{::bitsery::Access::create<typename T::value_type>()};
                    fnc(tmp);
                    obj = tmp;
                } else {
--- a/include/bitsery/ext/std_queue.h
+++ b/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);
@@ -82,14 +82,14 @@ namespace bitsery {
            }

            //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 Writer, typename T, typename C, typename Comp, typename Fnc>
+            void serialize(Ser &ser, Writer &, 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 Reader, typename T, typename C, typename Comp, typename Fnc>
+            void deserialize(Des &des, Reader &, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
+                des.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
            }

        };
--- a/include/bitsery/ext/std_set.h
+++ b/include/bitsery/ext/std_set.h
@@ -25,9 +25,9 @@

 #include <cassert>
 #include "../details/adapter_utils.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 {
@@ -54,26 +54,28 @@ namespace bitsery {

                size_t size{};
                details::readSize(reader, size, _maxSize);
-                auto hint = obj.begin();
                obj.clear();
                reserve(obj, size);
-
+                auto hint = obj.begin();
                for (auto i = 0u; i < size; ++i) {
-                    TKey key;
+                    auto key{bitsery::Access::create<TKey>()};
                    fnc(key);
                    hint = obj.emplace_hint(hint, std::move(key));
                }
            }
        private:

-            template <typename T>
-            void reserve(std::unordered_set<T>& obj, size_t size) const {
+            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
--- a/include/bitsery/ext/std_smart_ptr.h
+++ b/include/bitsery/ext/std_smart_ptr.h
@@ -46,7 +46,8 @@ 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();
                }

@@ -61,7 +62,7 @@ namespace bitsery {
                }

                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
--- a/include/bitsery/ext/utils/pointer_utils.h
+++ b/include/bitsery/ext/utils/pointer_utils.h
@@ -29,6 +29,7 @@
 #include <algorithm>
 #include <cassert>
 #include "../../details/adapter_utils.h"
+#include "../../details/serialization_common.h"

 namespace bitsery {
    namespace ext {
@@ -70,6 +71,24 @@ namespace bitsery {
                          isSharedProcessed{false} {};
                PointerOwnershipType ownershipType;
                bool isSharedProcessed;
+
+                void update(PointerOwnershipType ptrType) {
+                    //do nothing for observer
+                    if (ptrType == PointerOwnershipType::Observer)
+                        return;
+                    if (ownershipType == PointerOwnershipType::Observer) {
+                        //set ownership type
+                        ownershipType = ptrType;
+                        return;
+                    }
+                    //only shared ownership can get here multiple times
+                    assert(ptrType == PointerOwnershipType::SharedOwner || ptrType == PointerOwnershipType::SharedObserver);
+                    //check if need to update to SharedOwner
+                    if (ptrType == PointerOwnershipType::SharedOwner)
+                        ownershipType = ptrType;
+                    //mark that object already processed, so we do not serialize/deserialize duplicate objects
+                    isSharedProcessed = true;
+                }
            };

            struct PLCInfoSerializer: PLCInfo {
@@ -111,24 +130,6 @@ namespace bitsery {
                std::unique_ptr<PointerSharedStateBase> sharedState{};
            };

-            void updatePLCInfo(PLCInfo &ptrInfo, PointerOwnershipType ptrType) {
-                //do nothing for observer
-                if (ptrType == PointerOwnershipType::Observer)
-                    return;
-                if (ptrInfo.ownershipType == PointerOwnershipType::Observer) {
-                    //set ownership type
-                    ptrInfo.ownershipType = ptrType;
-                    return;
-                }
-                //only shared ownership can get here multiple times
-                assert(ptrType == PointerOwnershipType::SharedOwner || ptrType == PointerOwnershipType::SharedObserver);
-                //check if need to update to SharedOwner
-                if (ptrType == PointerOwnershipType::SharedOwner)
-                    ptrInfo.ownershipType = ptrType;
-                //mark that object already processed, so we do not serialize/deserialize duplicate objects
-                ptrInfo.isSharedProcessed = true;
-            }
-
            class PointerLinkingContextSerialization {
            public:
                explicit PointerLinkingContextSerialization()
@@ -152,7 +153,7 @@ namespace bitsery {
                        ++_currId;
                        return ptrInfo;
                    }
-                    updatePLCInfo(ptrInfo, ptrType);
+                    ptrInfo.update(ptrType);
                    return ptrInfo;
                }

@@ -191,7 +192,7 @@ namespace bitsery {
                    auto res = _idMap.emplace(id, PLCInfoDeserializer{nullptr, ptrType});
                    auto &ptrInfo = res.first->second;
                    if (!res.second)
-                        updatePLCInfo(ptrInfo, ptrType);
+                        ptrInfo.update(ptrType);
                    return ptrInfo;
                }

@@ -305,7 +306,7 @@ namespace bitsery {
                    if (ptr) {
                        fnc(*ptr);
                    } else {
-                        ptr = new typename TPtrManager<T>::TElement{};
+                        ptr = ::bitsery::Access::createInHeap<typename TPtrManager<T>::TElement>();
                        fnc(*ptr);
                        TPtrManager<T>::assign(obj, ptr);
                    }
@@ -340,7 +341,7 @@ namespace bitsery {
                            fnc(*ptr);
                            sharedState = TPtrManager<T>::saveToSharedState(obj);
                        } else {
-                            auto res = new typename TPtrManager<T>::TElement{};
+                            auto res = ::bitsery::Access::createInHeap<typename TPtrManager<T>::TElement>();
                            fnc(*res);
                            sharedState = TPtrManager<T>::createSharedState(res);
                        }
@@ -374,6 +375,7 @@ namespace bitsery {
                public pointer_utils::PointerLinkingContextSerialization,
                public pointer_utils::PointerLinkingContextDeserialization {
        public:
+            explicit PointerLinkingContext() = default;
            bool isValid() {
                return isPointerSerializationValid() && isPointerDeserializationValid();
            }
--- a/include/bitsery/ext/utils/polymorphism_utils.h
+++ b/include/bitsery/ext/utils/polymorphism_utils.h
@@ -26,6 +26,7 @@
 #include <unordered_map>
 #include <memory>
 #include "../../details/adapter_common.h"
+#include "../../details/serialization_common.h"

 namespace bitsery {

@@ -69,12 +70,12 @@ namespace bitsery {
        public:

            void *create() const final {
-                return toBase(new TDerived{});
-            };
+                return toBase(::bitsery::Access::createInHeap<TDerived>());
+            }

            void process(void *ser, void *obj) const final {
                static_cast<TSerializer *>(ser)->object(*static_cast<TDerived *>(fromBase(obj)));
-            };
+            }

        private:

@@ -108,23 +109,23 @@ namespace bitsery {
                }
            };

-            template<typename TSerializer, typename TBase, typename TDerived>
+            template<typename TSerializer, template<typename> class THierarchy, typename TBase, typename TDerived>
            void add() {
                addToMap<TSerializer, TBase, TDerived>(std::is_abstract<TDerived>{});
-                addChilds<TSerializer, TBase, TDerived>(typename PolymorphicBaseClass<TDerived>::Childs{});
+                addChilds<TSerializer, THierarchy, TBase, TDerived>(typename THierarchy<TDerived>::Childs{});
            }

-            template<typename TSerializer, typename TBase, typename TDerived, typename T1, typename ... Tn>
+            template<typename TSerializer, template<typename> class THierarchy, typename TBase, typename TDerived, typename T1, typename ... Tn>
            void addChilds(PolymorphicClassesList<T1, Tn...>) {
                static_assert(std::is_base_of<TDerived, T1>::value,
                              "PolymorphicBaseClass<TBase> must derive a list of derived classes from TBase.");
-                add<TSerializer, TBase, T1>();
-                addChilds<TSerializer, TBase, TDerived>(PolymorphicClassesList<Tn...>{});
+                add<TSerializer, THierarchy, TBase, T1>();
+                addChilds<TSerializer, THierarchy, TBase, TDerived>(PolymorphicClassesList<Tn...>{});
                //iterate through derived class hierarchy as well
-                add<TSerializer, T1, T1>();
+                add<TSerializer, THierarchy, T1, T1>();
            }

-            template<typename TSerializer, typename TBase, typename TDerived>
+            template<typename TSerializer, template<typename> class THierarchy, typename TBase, typename TDerived>
            void addChilds(PolymorphicClassesList<>) {
            }

@@ -154,16 +155,39 @@ namespace bitsery {
                _baseToDerivedArray.clear();
            }

-            template<typename TSerializer, typename T1, typename ...Tn>
-            void registerBasesList(const TSerializer &s, PolymorphicClassesList<T1, Tn...>) {
-                add<TSerializer, T1, T1>();
-                registerBasesList<TSerializer>(s, PolymorphicClassesList<Tn...>{});
+            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>
-            void registerBasesList(const TSerializer &, PolymorphicClassesList<>) {
+            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)
+            // https://github.com/fraillt/bitsery/issues/9
+            template<typename TSerializer, template<typename> class THierarchy = PolymorphicBaseClass, typename T1, typename ...Tn>
+            void registerBasesList(PolymorphicClassesList<T1, Tn...>) {
+                add<TSerializer, THierarchy, T1, T1>();
+                registerBasesList<TSerializer, THierarchy>(PolymorphicClassesList<Tn...>{});
+            }
+
+            template<typename TSerializer, template<typename> class THierarchy>
+            void registerBasesList(PolymorphicClassesList<>) {
+            }
+
+            // optional method, in case you want to construct base class hierarchy your self
+            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");
+                addToMap<TSerializer, TBase, TDerived>(std::false_type{});
+            }
+
+
            template<typename Serializer, typename Writer, typename TBase>
            void serialize(Serializer &ser, Writer &writer, TBase &obj) {
                //get derived key
--- a/include/bitsery/ext/value_range.h
+++ b/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,7 +164,8 @@ 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 {
--- a/include/bitsery/flexible/deque.h
+++ b/include/bitsery/flexible/deque.h
@@ -28,8 +28,8 @@
 #include "../details/flexible_common.h"

 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::deque<TArgs... > &obj) {
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::deque<T, Allocator> &obj) {
        flexible::processContainer(s, obj);
    }
 }
--- a/include/bitsery/flexible/forward_list.h
+++ b/include/bitsery/flexible/forward_list.h
@@ -28,8 +28,8 @@
 #include "../details/flexible_common.h"

 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::forward_list<TArgs... > &obj) {
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::forward_list<T, Allocator> &obj) {
        flexible::processContainer(s, obj);
    }
 }
--- a/include/bitsery/flexible/list.h
+++ b/include/bitsery/flexible/list.h
@@ -28,8 +28,8 @@
 #include "../details/flexible_common.h"

 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::list<TArgs... > &obj) {
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::list<T, Allocator> &obj) {
        flexible::processContainer(s, obj);
    }
 }
--- a/include/bitsery/flexible/map.h
+++ b/include/bitsery/flexible/map.h
@@ -28,23 +28,19 @@
 #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](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](Key& key, T& value) {
                  s.object(key);
                  s.object(value);
              });
--- a/include/bitsery/flexible/set.h
+++ b/include/bitsery/flexible/set.h
@@ -28,13 +28,13 @@
 #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 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::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});
    }

--- a/include/bitsery/flexible/string.h
+++ b/include/bitsery/flexible/string.h
@@ -28,8 +28,8 @@
 #include "../details/flexible_common.h"

 namespace bitsery {
-    template<typename S, typename T, typename ... TArgs>
-    void serialize(S &s, std::basic_string<T, TArgs...> &str) {
+    template<typename S, typename CharT, typename Traits, typename Allocator>
+    void serialize(S &s, std::basic_string<CharT, Traits, Allocator> &str) {
        flexible::processContainer(s, str);
    }
 }
--- a/include/bitsery/flexible/unordered_map.h
+++ b/include/bitsery/flexible/unordered_map.h
@@ -28,23 +28,19 @@
 #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](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](Key& key, T& value) {
                  s.object(key);
                  s.object(value);
              });
--- a/include/bitsery/flexible/unordered_set.h
+++ b/include/bitsery/flexible/unordered_set.h
@@ -28,13 +28,13 @@
 #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 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::unordered_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});
    }

--- a/include/bitsery/flexible/vector.h
+++ b/include/bitsery/flexible/vector.h
@@ -28,8 +28,8 @@
 #include "../details/flexible_common.h"

 namespace bitsery {
-    template<typename S, typename ... TArgs>
-    void serialize(S &s, std::vector<TArgs... > &obj) {
+    template<typename S, typename T, typename Allocator>
+    void serialize(S &s, std::vector<T, Allocator> &obj) {
        flexible::processContainer(s, obj);
    }
 }
--- a/include/bitsery/traits/core/std_defaults.h
+++ b/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;
        };

@@ -73,9 +88,10 @@ namespace bitsery {
                auto newSize = static_cast<size_t>(container.size() * 1.5 + 128);
                //make data cache friendly
                newSize -= newSize % 64;//64 is cache line size
-                container.resize(std::max(newSize, container.capacity()));
+                container.resize((std::max)(newSize, container.capacity()));
            }
            using TIterator = typename T::iterator;
+            using TConstIterator = typename T::const_iterator;
            using TValue = typename ContainerTraits<T>::TValue;
        };

--- a/include/bitsery/traits/core/traits.h
+++ b/include/bitsery/traits/core/traits.h
@@ -155,6 +155,7 @@ namespace bitsery {
            }

            using TIterator = details::NotDefinedType;
+            using TConstIterator = details::NotDefinedType;
            using TValue = typename ContainerTraits<T>::TValue;
        };

@@ -162,6 +163,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 +171,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;
        };

--- a/include/bitsery/traits/deque.h
+++ b/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> {};

    }

--- a/include/bitsery/traits/forward_list.h
+++ b/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();
+                }
+            }
        };
    }
 }
--- a/include/bitsery/traits/list.h
+++ b/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> {};

    }

--- a/include/bitsery/traits/string.h
+++ b/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>> {};

    }

--- a/include/bitsery/traits/vector.h
+++ b/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>> {};

    }

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -44,7 +44,7 @@ foreach (TestFile ${TestSourceFiles})
    add_executable(${TestName} ${TestFile})
    target_link_libraries(${TestName} PRIVATE GTest::Main Bitsery::bitsery)
    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-        target_compile_options(${TestName} PRIVATE -Wextra -Wno-missing-braces -Wpedantic -Weffc++)
+        target_compile_options(${TestName} PRIVATE -Wextra -Wno-missing-braces -Wpedantic -Weffc++ -Wno-c++14-extensions)
    endif()

    add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)
--- a/tests/data_endianness.cpp
+++ b/tests/data_endianness.cpp
@@ -56,19 +56,19 @@ using InverseReader = bitsery::AdapterReader<InputAdapter, InverseEndiannessConf
 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{};
--- a/tests/data_reading.cpp
+++ b/tests/data_reading.cpp
@@ -153,3 +153,28 @@ TEST(DataReading, WhenReaderHasErrorsAllOperationsReadsReturnZero) {
    EXPECT_THAT(r2[1], Eq(0u));
    EXPECT_THAT(r3, Eq(0u));
 }
+
+TEST(DataReading, ConstBufferAllAdapters) {
+    //create and write to buffer
+    uint16_t data = 7549;
+    Buffer bufWrite{};
+    Writer bw{bufWrite};
+    bw.writeBytes<2>(data);
+    bw.flush();
+    const Buffer buf{bufWrite};
+
+    //read from buffer
+    using Adapter1 = bitsery::InputBufferAdapter<const Buffer>;
+    using Adapter2 = bitsery::UnsafeInputBufferAdapter<const Buffer>;
+
+    bitsery::AdapterReader<Adapter1, bitsery::DefaultConfig> r1{Adapter1{buf.begin(), buf.end()}};
+    bitsery::AdapterReader<Adapter2, bitsery::DefaultConfig> r2{Adapter2{buf.begin(), buf.end()}};
+
+    uint16_t res1{};
+    r1.readBytes<2>(res1);
+
+    uint16_t res2{};
+    r2.readBytes<2>(res2);
+    EXPECT_THAT(res1, Eq(data));
+    EXPECT_THAT(res2, Eq(data));
+}
--- a/tests/not_default_constructible.cpp
+++ b/tests/not_default_constructible.cpp
@@ -0,0 +1,328 @@
+//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()));
+
+    }
+}
+
+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},[&ser](NonDefaultConstructible& key, NonDefaultConstructible& value) {
+        ser.object(key);
+        ser.object(value);
+    });
+    auto& des = ctx.createDeserializer();
+    des.ext(res, bitsery::ext::StdMap{10},[&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::DefaultConfig, 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<bitsery::DefaultConfig, 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{};
+    std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
+    TContext desCtx{};
+    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));
+}
--- a/tests/serialization_ext_compact_value.cpp
+++ b/tests/serialization_ext_compact_value.cpp
@@ -0,0 +1,241 @@
+//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/ext/compact_value.h>
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+
+#include <bitsery/traits/array.h>
+#include <iostream>
+#include <bitset>
+#include <chrono>
+
+using testing::Eq;
+using bitsery::ext::CompactValue;
+using bitsery::ext::CompactValueAsObject;
+using bitsery::EndiannessType;
+
+// helper function, that gets value filled with specified number of bits
+template <typename TValue>
+TValue getValue(bool isPositive, size_t significantBits) {
+    TValue v = isPositive ? 0 : -1;
+    if (significantBits == 0)
+        return v;
+
+    using TUnsigned = typename std::make_unsigned<TValue>::type;
+    TUnsigned mask = {};
+    mask = ~mask; // invert shiftByBits
+    auto shiftBy = bitsery::details::BitsSize<TValue>::value - significantBits;
+    mask >>= shiftBy;
+    //cast to unsigned when applying mask
+    return (TUnsigned)v ^ mask;
+}
+
+// helper function, that serialize and return deserialized value
+template <typename TSerContext, 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()};
+}
+
+struct LittleEndianConfig: public bitsery::DefaultConfig {
+    static constexpr EndiannessType NetworkEndianness = EndiannessType::LittleEndian;
+};
+
+struct BigEndianConfig: public bitsery::DefaultConfig {
+    static constexpr EndiannessType NetworkEndianness = EndiannessType::BigEndian;
+};
+
+template <typename TValue, bool isPositiveNr, typename TConfig>
+struct TC {
+    static_assert(isPositiveNr || std::is_signed<TValue>::value, "");
+
+    using Value = TValue;
+    using Config = TConfig;
+    bool isPositive = isPositiveNr;
+};
+
+template<typename T>
+class SerializeExtensionCompactValueCorrectness : public testing::Test {
+public:
+    using TestCase = T;
+};
+
+
+using AllValueSizesTestCases = ::testing::Types<
+        TC<uint8_t, true, LittleEndianConfig>,
+        TC<uint16_t, true, LittleEndianConfig>,
+        TC<uint32_t, true, LittleEndianConfig>,
+        TC<uint64_t, true, LittleEndianConfig>,
+        TC<int8_t, true, LittleEndianConfig>,
+        TC<int16_t, true, LittleEndianConfig>,
+        TC<int32_t, true, LittleEndianConfig>,
+        TC<int64_t, true, LittleEndianConfig>,
+        TC<int8_t, false, LittleEndianConfig>,
+        TC<int16_t, false, LittleEndianConfig>,
+        TC<int32_t, false, LittleEndianConfig>,
+        TC<int64_t, false, LittleEndianConfig>,
+        TC<uint8_t, true, BigEndianConfig>,
+        TC<uint16_t, true, BigEndianConfig>,
+        TC<uint32_t, true, BigEndianConfig>,
+        TC<uint64_t, true, BigEndianConfig>,
+        TC<int8_t, true, BigEndianConfig>,
+        TC<int16_t, true, BigEndianConfig>,
+        TC<int32_t, true, BigEndianConfig>,
+        TC<int64_t, true, BigEndianConfig>,
+        TC<int8_t, false, BigEndianConfig>,
+        TC<int16_t, false, BigEndianConfig>,
+        TC<int32_t, false, BigEndianConfig>,
+        TC<int64_t, false, BigEndianConfig>
+>;
+
+TYPED_TEST_CASE(SerializeExtensionCompactValueCorrectness, AllValueSizesTestCases);
+
+TYPED_TEST(SerializeExtensionCompactValueCorrectness, TestDifferentSizeValues) {
+    using TCase = typename TestFixture::TestCase;
+    using TValue = typename TCase::Value;
+    TCase tc{};
+
+    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);
+        EXPECT_THAT(res.first, Eq(data));
+    }
+}
+
+
+// this stucture will contain test data and result, as type paramters
+template <typename TValue, bool isPositiveNr, size_t significantBits, size_t resultBytes>
+struct SizeTC {
+    static_assert(isPositiveNr || std::is_signed<TValue>::value, "");
+    static_assert(bitsery::details::BitsSize<TValue>::value >= significantBits, "");
+
+    using Value = TValue;
+    bool isPositive = isPositiveNr;
+    size_t fillBits = significantBits;
+    size_t bytesCount = resultBytes;
+};
+
+template<typename T>
+class SerializeExtensionCompactValueRequiredBytes : public testing::Test {
+public:
+    using TestCase = T;
+};
+
+using RequiredBytesTestCases = ::testing::Types<
+        //1 byte always writes to 1 byte
+        SizeTC<uint8_t, true, 0,1>,
+        SizeTC<uint8_t, true, 8,1>,
+        SizeTC<int8_t, false, 0,1>,
+        SizeTC<int8_t, true, 8,1>,
+
+        //2 byte, +1 byte after 15 significant bits
+        SizeTC<uint16_t, true, 7,1>,
+        SizeTC<uint16_t, true, 8,2>,
+        SizeTC<uint16_t, true, 14,2>,
+        SizeTC<uint16_t, true, 15,3>,
+        //2 byte, +1 byte after 15-1 significant bits (1 bit for sign)
+        SizeTC<int16_t, true, 6,1>,
+        SizeTC<int16_t, false, 7,2>,
+        SizeTC<int16_t, true, 13,2>,
+        SizeTC<int16_t, false, 14,3>,
+
+        //4 byte, +1 byte after 29 significant bits
+        SizeTC<uint32_t, true, 14,2>,
+        SizeTC<uint32_t, true, 21,3>,
+        SizeTC<uint32_t, true, 28,4>,
+        SizeTC<uint32_t, true, 29,5>,
+        SizeTC<uint32_t, true, 32,5>,
+        //4 byte
+        SizeTC<int32_t, true, 13,2>,
+        SizeTC<int32_t, false, 20,3>,
+        SizeTC<int32_t, true, 27,4>,
+        SizeTC<int32_t, false, 28,5>,
+        SizeTC<int32_t, true, 31,5>,
+
+        //8 byte, +1 byte after 57 significant bits, or +2 byte when all bits are significant
+        SizeTC<uint64_t, true, 28,4>,
+        SizeTC<uint64_t, true, 35,5>,
+        SizeTC<uint64_t, true, 42,6>,
+        SizeTC<uint64_t, true, 49,7>,
+        SizeTC<uint64_t, true, 56,8>,
+        SizeTC<uint64_t, true, 57,9>,
+        SizeTC<uint64_t, true, 63,9>,
+        SizeTC<uint64_t, true, 64,10>,
+        //8 byte,
+        SizeTC<int64_t, true, 27,4>,
+        SizeTC<int64_t, false, 34,5>,
+        SizeTC<int64_t, true, 41,6>,
+        SizeTC<int64_t, false, 48,7>,
+        SizeTC<int64_t, true, 55,8>,
+        SizeTC<int64_t, false, 56,9>,
+        SizeTC<int64_t, true, 62,9>,
+        SizeTC<int64_t, false, 63,10>
+>;
+
+TYPED_TEST_CASE(SerializeExtensionCompactValueRequiredBytes, RequiredBytesTestCases);
+
+TYPED_TEST(SerializeExtensionCompactValueRequiredBytes, Test) {
+    using TCase = typename TestFixture::TestCase;
+    using TValue = typename TCase::Value;
+    TCase tc{};
+    TValue data = getValue<TValue>(tc.isPositive, tc.fillBits);
+    auto res = serializeAndGetDeserialized<SerializationContext>(data);
+    EXPECT_THAT(res.first, Eq(data));
+    EXPECT_THAT(res.second, tc.bytesCount);
+}
+
+enum b1En: uint8_t {
+    A,B,C,D=54,E
+};
+
+enum class b8En: int64_t {
+    A=-874987489,B,C=0,D,E=489748978, F,G
+};
+
+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));
+}
+
+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);
+    EXPECT_THAT(data, ::testing::Ne(res));
+    EXPECT_THAT(rd.error(), Eq(bitsery::ReaderError::DataOverflow));
+}
+
+
--- a/tests/serialization_ext_growable.cpp
+++ b/tests/serialization_ext_growable.cpp
@@ -52,9 +52,9 @@ TEST(SerializeExtensionGrowable, WriteSessionsDataAtBufferEndAfterFlush) {
        ser.value1b(v);
    });

-    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(1u));
    ctx.bw->flush();
-    EXPECT_THAT(ctx.getBufferSize(), Gt(1));
+    EXPECT_THAT(ctx.getBufferSize(), Gt(1u));
 }


--- a/tests/serialization_ext_pointer_polymorphic_types.cpp
+++ b/tests/serialization_ext_pointer_polymorphic_types.cpp
@@ -152,7 +152,7 @@ public:
        auto &res = sctx.createSerializer(&plctx);
        std::get<2>(plctx).clear();
        //bind serializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).registerBasesList<SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -160,7 +160,7 @@ public:
        auto &res = sctx.createDeserializer(&plctx);
        std::get<2>(plctx).clear();
        //bind deserializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).registerBasesList<SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -322,7 +322,7 @@ TEST_F(SerializeExtensionPointerPolymorphicTypes,
    auto &des = sctx.createDeserializer(&plctx);
    auto &pc = std::get<2>(plctx);
    pc.clear();
-    pc.registerBasesList(des, bitsery::ext::PolymorphicClassesList<BaseClone>{});
+    pc.registerBasesList<SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<BaseClone>{});
    des.ext(baseRes, PointerOwner{});
    EXPECT_THAT(sctx.br->error(), Eq(bitsery::ReaderError::InvalidPointer));
 }
--- a/tests/serialization_ext_std_optional.cpp
+++ b/tests/serialization_ext_std_optional.cpp
@@ -33,10 +33,10 @@

 using StdOptional = bitsery::ext::StdOptional;

-using testing::Eq;
+using BPSer = SerializationContext::TSerializer::BPEnabledType;
+using BPDes = SerializationContext::TDeserializer::BPEnabledType;

-using BPSer = bitsery::BasicSerializer<Writer, true>;
-using BPDes = bitsery::BasicDeserializer<Reader, true>;
+using testing::Eq;

 template <typename T>
 void test(SerializationContext& ctx, const T& v, T& r) {
@@ -117,7 +117,6 @@ TEST(SerializeExtensionStdOptional, NoAlignAfterStateWriteRead) {
        });
    });

-
    EXPECT_THAT(range.getRequiredBits() + 1, ::testing::Lt(8));
    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
    EXPECT_THAT(t1.value(), Eq(r1.value()));
--- a/tests/serialization_ext_std_set.cpp
+++ b/tests/serialization_ext_std_set.cpp
@@ -35,7 +35,7 @@ class SerializeExtensionStdSet : public testing::Test {
 public:
    using TContainer = T;
    const TContainer src = {4, 8, 48, 4, 9845, 64, 8};
-    TContainer res{};
+    TContainer res{78,74,154,8};
 };

 using SerializeExtensionStdSetTypes = ::testing::Types<
@@ -65,7 +65,7 @@ TEST(SerializeExtensionStdSet, ObjectSyntax) {
 TEST(SerializeExtensionStdSet, FunctionSyntax) {
    SerializationContext ctx1;
    std::unordered_multiset<int32_t> t1{54,-484,841,79};
-    std::unordered_multiset<int32_t> r1{};
+    std::unordered_multiset<int32_t> r1{74,878,15,16,-7,5,-4,8,7};
    auto& ser = ctx1.createSerializer();
    ser.ext(t1, StdSet{10}, [&ser](int32_t& v) {
        ser.value4b(v);
@@ -75,4 +75,4 @@ TEST(SerializeExtensionStdSet, FunctionSyntax) {
        des.value4b(v);
    });
    EXPECT_THAT(r1, Eq(t1));
-}
+}
--- a/tests/serialization_ext_std_smart_ptr.cpp
+++ b/tests/serialization_ext_std_smart_ptr.cpp
@@ -160,7 +160,7 @@ public:
        auto &res = sctx.createSerializer(&plctx);
        std::get<2>(plctx).clear();
        //bind serializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).template registerBasesList<SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -168,7 +168,7 @@ public:
        auto &res = sctx.createDeserializer(&plctx);
        std::get<2>(plctx).clear();
        //bind deserializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).template registerBasesList<SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -407,7 +407,7 @@ public:
        auto &res = sctx.createSerializer(&plctx);
        std::get<2>(plctx).clear();
        //bind serializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).registerBasesList<SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -415,7 +415,7 @@ public:
        auto &res = sctx.createDeserializer(&plctx);
        std::get<2>(plctx).clear();
        //bind deserializer with classes
-        std::get<2>(plctx).registerBasesList(res, bitsery::ext::PolymorphicClassesList<Base>{});
+        std::get<2>(plctx).registerBasesList<SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<Base>{});
        return res;
    }

@@ -653,6 +653,7 @@ TEST_F(SerializeExtensionStdSmartSharedPtr, WhenOnlyWeakPtrIsDeserializedThenPoi

 struct TestSharedFromThis : public std::enable_shared_from_this<TestSharedFromThis> {
    float x{};
+    explicit TestSharedFromThis(): std::enable_shared_from_this<TestSharedFromThis>() {}

    template<typename S>
    void serialize(S &s) {
@@ -670,3 +671,20 @@ TEST_F(SerializeExtensionStdSmartSharedPtr, EnableSharedFromThis) {
    EXPECT_THAT(resPtr->x, Eq(dataPtr->x));
    EXPECT_THAT(resPtr2.use_count(), Eq(2));
 }
+
+struct CustomDeleter {
+    void operator()(Base*p) {
+        delete p;
+    }
+};
+class SerializeExtensionStdSmartUniquePtr:public SerializeExtensionStdSmartSharedPtr{};
+
+TEST_F(SerializeExtensionStdSmartUniquePtr, WithCustomDeleter) {
+    std::unique_ptr<Base, CustomDeleter> dataPtr(new Derived{87,7});
+    std::unique_ptr<Base, CustomDeleter> resPtr{};
+    createSerializer().ext(dataPtr, StdSmartPtr{});
+    createDeserializer().ext(resPtr, StdSmartPtr{});
+    clearSharedState();
+    EXPECT_THAT(resPtr->x, Eq(dataPtr->x));
+    EXPECT_THAT(dynamic_cast<Derived *>(resPtr.get()), ::testing::NotNull());
+}
--- a/tests/serialization_size.cpp
+++ b/tests/serialization_size.cpp
@@ -37,26 +37,26 @@ bool SerializeDeserializeContainerSize(SerializationContext& ctx, const size_t s
 TEST(SerializeSize, WhenLengthLessThan128Then1Byte) {
    SerializationContext ctx1{};
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx1, 127));
-    EXPECT_THAT(ctx1.getBufferSize(), Eq(1));
+    EXPECT_THAT(ctx1.getBufferSize(), Eq(1u));
    SerializationContext ctx2;
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx2, 128));
-    EXPECT_THAT(ctx2.getBufferSize(), testing::Gt(1));
+    EXPECT_THAT(ctx2.getBufferSize(), testing::Gt(1u));
 }

 TEST(SerializeSize, WhenLengthLessThan16384Then2Bytes) {
    SerializationContext ctx1;
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx1, 16383));
-    EXPECT_THAT(ctx1.getBufferSize(), Eq(2));
+    EXPECT_THAT(ctx1.getBufferSize(), Eq(2u));
    SerializationContext ctx2;
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx2, 16384));
-    EXPECT_THAT(ctx2.getBufferSize(), testing::Gt(2));
+    EXPECT_THAT(ctx2.getBufferSize(), testing::Gt(2u));
 }

 TEST(SerializeSize, WhenGreaterThan16383Then4Bytes) {
    SerializationContext ctx1;
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx1, 16384));
-    EXPECT_THAT(ctx1.getBufferSize(), Eq(4));
+    EXPECT_THAT(ctx1.getBufferSize(), Eq(4u));
    SerializationContext ctx2;
    EXPECT_TRUE(SerializeDeserializeContainerSize(ctx2, 66384));
-    EXPECT_THAT(ctx2.getBufferSize(), Eq(4));
-}
+    EXPECT_THAT(ctx2.getBufferSize(), Eq(4u));
+}
Author	SHA1	Message	Date
Mindaugas	a6dad0885f	visual studio variadic templates issues	2019-01-16 11:27:56 +02:00
Mindaugas	65f90637df	input buffer adapter accepts const buffer	2019-01-10 20:48:03 +02:00
Mindaugas	b10f86da00	non default constructible types	2019-01-10 19:08:15 +02:00
Mindaugas	6c3e1aee43	removed anonymous namespace from PolymorphicBaseClass as it only works on clang, and is not standard compliant	2019-01-08 16:00:02 +02:00
Mindaugas	e5f8d5742f	Merge branch 'master' of https://github.com/fraillt/bitsery	2019-01-08 15:08:27 +02:00
Mindaugas	a2ecf8d7b0	polymorphism improvements and new CompactValue extension	2019-01-08 15:06:29 +02:00
Mindaugas Vinkelis	670130397b	Merge pull request #6 from AJIOB/master VS 2017.5.6 example project compilation fix	2018-09-17 09:47:36 +03:00
AJIOB	4a0b3cae98	VS 2017.5.6 example compilation fix	2018-09-15 08:37:56 +03:00
Mindaugas Vinkelis	b3b32ab393	Merge pull request #5 from YarikTH/patch-1 Update smart_pointers_with_polymorphism.cpp	2018-08-27 07:24:22 +03:00
Yaroslav	6ebdb9915b	Update smart_pointers_with_polymorphism.cpp Fix Color::operator == in smart_pointers_with_polymorphism example	2018-08-24 10:09:17 +03:00
Mindaugas	2e62bd08e3	cleanup	2018-08-23 14:57:48 +03:00