added endianness support

CHANGELOG.md

@@ -0,0 +1 @@
+#

CMakeLists.txt

@@ -1,23 +1,12 @@
 cmake_minimum_required(VERSION 3.2)
 
-set(PROJECT_NAME bitsery)
-set(TEST_PROJECT_NAME ${PROJECT_NAME}_tests)
-project(${PROJECT_NAME})
+project(bitsery)
 
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -g -O0 -fprofile-arcs -ftest-coverage")
-
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-
-
-set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/ext)
-if(CMAKE_COMPILER_IS_GNUCXX)
-    include(CodeCoverage)
-    setup_target_for_coverage(${PROJECT_NAME}_coverage ${TEST_PROJECT_NAME} coverage)
-endif()
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 add_subdirectory(examples)
 
-#add tests
 enable_testing()
 add_subdirectory(tests)

examples/CMakeLists.txt

@@ -25,14 +25,11 @@ cmake_minimum_required(VERSION 3.2)
 
 include_directories(${CMAKE_SOURCE_DIR}/include)
 
-file(GLOB EXAMPLE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB ExampleFiles ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 
-FOREACH(EXAMPLE ${EXAMPLE_FILES})
-    get_filename_component(EXAMPLE_NAME ${EXAMPLE} NAME_WE)
-    add_executable(${EXAMPLE_NAME} ${EXAMPLE})
-
-    set_property(TARGET ${EXAMPLE_NAME} PROPERTY CXX_STANDARD 14)
-    set_property(TARGET ${EXAMPLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
+FOREACH(ExampleFile ${ExampleFiles})
+    get_filename_component(ExampleName ${ExampleFile} NAME_WE)
+    add_executable(${ExampleName} ${ExampleFile})
 
 ENDFOREACH()
 

examples/basic_usage.cpp

@@ -35,9 +35,9 @@ struct MyStruct {
 //define how object should be serialized/deserialized
 SERIALIZE(MyStruct) {
     return s.
-            value(o.i).
-            value(o.e).
-            container(o.fs, 100);
+            value4(o.i).
+            value4(o.e).
+            container4(o.fs, 100);
 }
 
 using namespace bitsery;

ext/CodeCoverage.cmake

@@ -146,7 +146,8 @@ FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
 
 		# Capturing lcov counters and generating report
 		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
-		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' --output-file ${coverage_cleaned}
+			#extract only /include/bitsery directory
+		COMMAND ${LCOV_PATH} --extract ${coverage_info} '*include/bitsery*' --output-file ${coverage_cleaned}
 		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
 		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
 

ext/LinkTestLIb.cmake

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

ext/gtest/CMakeLists.txt

@@ -24,32 +24,32 @@ cmake_minimum_required(VERSION 3.2)
 project(gtest_builder C CXX)
 include(ExternalProject)
 
-set(GTEST_FORCE_SHARED_CRT ON)
-set(GTEST_DISABLE_PTHREADS OFF)
+set(ForceSharedCrt ON)
+set(DisablePThreads OFF)
 
 if(MINGW)
-    set(GTEST_DISABLE_PTHREADS ON)
+    set(DisablePThreads ON)
 endif()
 
-if (${USE_GMOCK})
+if (${UseGMock})
     message("use gmock")
-    set(BUILD_ARGS -DBUILD_GTEST=OFF -DBUILD_GMOCK=ON)
+    set(BuildArgs -DBUILD_GTEST=OFF -DBUILD_GMOCK=ON)
 else ()
     message("use gtest only")
-    set(BUILD_ARGS -DBUILD_GTEST=ON -DBUILD_GMOCK=OFF)
+    set(BuildArgs -DBUILD_GTEST=ON -DBUILD_GMOCK=OFF)
 endif()
 
 if (WIN32 AND NOT MINGW)
-    set(BUILD_ARGS ${BUILD_ARGS}
+    set(BuildArgs ${BuildArgs}
             -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG:PATH=DebugLibs
             -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE:PATH=ReleaseLibs)
 endif()
 
 ExternalProject_Add(googletest
         GIT_REPOSITORY https://github.com/google/googletest.git
-        CMAKE_ARGS ${BUILD_ARGS}
-        -Dgtest_force_shared_crt=${GTEST_FORCE_SHARED_CRT}
-        -Dgtest_disable_pthreads=${GTEST_DISABLE_PTHREADS}
+        CMAKE_ARGS ${BuildArgs}
+        -Dgtest_force_shared_crt=${ForceSharedCrt}
+        -Dgtest_disable_pthreads=${DisablePThreads}
         PREFIX "${CMAKE_CURRENT_BINARY_DIR}"
         # disable update command
         UPDATE_COMMAND ""
@@ -60,20 +60,20 @@ ExternalProject_Add(googletest
 #export variables
 ExternalProject_Get_Property(googletest source_dir)
 ExternalProject_Get_Property(googletest binary_dir)
-if (${USE_GMOCK})
+if (${UseGMock})
     # need to include both googletest and googlemock
-    set(GTEST_INCLUDE_DIRS ${source_dir}/googlemock/include ${source_dir}/googletest/include PARENT_SCOPE)
-    set(GTEST_LIBS_DIR ${binary_dir}/googlemock PARENT_SCOPE)
-    set(GTEST_LIBNAME gmock PARENT_SCOPE)
-    set(GTEST_MAIN_LIBNAME gmock_main PARENT_SCOPE)
-    set(GTEST_LINK_LIBNAMES gmock_main PARENT_SCOPE)
+    set(GTestIncludeDirs ${source_dir}/googlemock/include ${source_dir}/googletest/include PARENT_SCOPE)
+    set(GTestLibsDir ${binary_dir}/googlemock PARENT_SCOPE)
+    set(GTestLibName gmock PARENT_SCOPE)
+    set(GTestMainLibName gmock_main PARENT_SCOPE)
+    set(GTestLinkLibNames gmock_main PARENT_SCOPE)
 else()
-    set(GTEST_INCLUDE_DIRS ${source_dir}/googletest/include PARENT_SCOPE)
-    set(GTEST_LIBS_DIR ${binary_dir}/googletest PARENT_SCOPE)
-    set(GTEST_LIBNAME gtest PARENT_SCOPE)
-    set(GTEST_MAIN_LIBNAME gtest_main PARENT_SCOPE)
+    set(GTestIncludeDirs ${source_dir}/googletest/include PARENT_SCOPE)
+    set(GTestLibsDir ${binary_dir}/googletest PARENT_SCOPE)
+    set(GTestLibName gtest PARENT_SCOPE)
+    set(GTestMainLibName gtest_main PARENT_SCOPE)
     # need to include both libs gtest and gtest_main
-    set(GTEST_LINK_LIBNAMES gtest gtest_main PARENT_SCOPE)
+    set(GTestLinkLibNames gtest gtest_main PARENT_SCOPE)
 endif()
 
 

include/bitsery/buffer_reader.h

@@ -32,28 +32,33 @@
 
 namespace bitsery {
 
-    struct BufferReader {
+    template <typename Config>
+    struct BasicBufferReader {
+        using ValueType = typename Config::BufferValueType;
+        using ScratchType = typename Config::BufferScrathType;
 
-        using value_type = uint8_t;
-
-        BufferReader(const std::vector<uint8_t> &buf)
-                : _pos{buf.data()},
-                  _end{buf.data() + buf.size()} {
-
-        }
-
-        BufferReader(const uint8_t* data, size_t size)
-                : _pos{data},
-                  _end{data + size}
+        BasicBufferReader(const ValueType* data, size_t size) : _pos{data}, _end{data + size}
         {
+            static_assert(std::is_unsigned<ValueType>(), "Config::BufferValueType must be unsigned");
+            static_assert(std::is_unsigned<ScratchType>(), "Config::BufferScrathType must be unsigned");
+            static_assert(sizeof(ValueType)*2 == sizeof(ScratchType), "ScratchType must be 2x bigger than value type");
+            static_assert(sizeof(ValueType) == 1, "currently only supported BufferValueType is 1 byte");
         }
+
+        explicit BasicBufferReader(const std::vector<ValueType> &buf) : BasicBufferReader(buf.data(), buf.size()) {
+        }
+
         template <size_t N>
-        BufferReader(const uint8_t (&data)[N])
-                : _pos{data},
-                  _end{data + N}
+        explicit BasicBufferReader(const ValueType (&data)[N]): BasicBufferReader(data, N)
         {
         }
 
+        BasicBufferReader(const BasicBufferReader&) = delete;
+        BasicBufferReader& operator=(const BasicBufferReader& ) = delete;
+        BasicBufferReader(BasicBufferReader&&) noexcept = default;
+        BasicBufferReader& operator=(BasicBufferReader&&) noexcept = default;
+        ~BasicBufferReader() noexcept = default;
+
 
         template<size_t SIZE, typename T>
         bool readBytes(T &v) {
@@ -62,7 +67,7 @@ namespace bitsery {
             using UT = typename std::make_unsigned<T>::type;
             return !m_scratch
                    ? directRead(&v, 1)
-                   : readBits(reinterpret_cast<UT &>(v), BITS_SIZE<T>);
+                   : readBits(reinterpret_cast<UT &>(v), details::BITS_SIZE<T>);
         }
 
         template<size_t SIZE, typename T>
@@ -70,16 +75,15 @@ namespace bitsery {
             static_assert(std::is_integral<T>(), "");
             static_assert(sizeof(T) == SIZE, "");
 
-            if (!m_scratchBits) {
+            if (!m_scratchBits)
                 return directRead(buf, count);
-            } else {
-                using UT = typename std::make_unsigned<T>::type;
-                //todo improve implementation
-                const auto end = buf + count;
-                for (auto it = buf; it != end; ++it) {
-                    if (!readBits(reinterpret_cast<UT &>(*it), BITS_SIZE<T>))
-                        return false;
-                }
+
+            using UT = typename std::make_unsigned<T>::type;
+            //todo improve implementation
+            const auto end = buf + count;
+            for (auto it = buf; it != end; ++it) {
+                if (!readBits(reinterpret_cast<UT &>(*it), details::BITS_SIZE<T>))
+                    return false;
             }
             return true;
         }
@@ -88,7 +92,7 @@ namespace bitsery {
         template<typename T>
         bool readBits(T &v, size_t bitsCount) {
             static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            assert(bitsCount <= BITS_SIZE<T>);
+            assert(bitsCount <= details::BITS_SIZE<T>);
 
             const auto bytesRequired = bitsCount > m_scratchBits
                                        ? ((bitsCount - 1 - m_scratchBits) >> 3) + 1u
@@ -101,8 +105,8 @@ namespace bitsery {
 
         bool align() {
             if (m_scratchBits) {
-                SCRATCH_TYPE tmp{};
-                readBitsInternal(tmp, BITS_SIZE<value_type> - m_scratchBits);
+                ScratchType tmp{};
+                readBitsInternal(tmp, m_scratchBits);
                 return tmp == 0;
             }
             return true;
@@ -113,8 +117,8 @@ namespace bitsery {
         }
 
     private:
-        const value_type* _pos;
-        const value_type* _end;
+        const ValueType* _pos;
+        const ValueType* _end;
 
         template<typename T>
         bool directRead(T *v, size_t count) {
@@ -122,28 +126,39 @@ namespace bitsery {
             const auto bytesCount = sizeof(T) * count;
             if (static_cast<size_t>(std::distance(_pos, _end)) < bytesCount)
                 return false;
-            std::copy_n(_pos, bytesCount, reinterpret_cast<value_type *>(v));
+            //read from buffer, to data ptr,
+            std::copy_n(_pos, bytesCount, reinterpret_cast<ValueType *>(v));
             std::advance(_pos, bytesCount);
+            //swap each byte if nessesarry
+            _swapDataBits(v, count, std::integral_constant<bool,
+                    Config::NetworkEndianness != details::getSystemEndianness()>{});
             return true;
         }
 
+        template<typename T>
+        void _swapDataBits(T *v, size_t count, std::true_type) {
+            std::for_each(v, std::next(v, count), [this](T& v) { v = details::swap(v); });
+        }
+
+        template<typename T>
+        void _swapDataBits(T *v, size_t count, std::false_type) {
+            //empty function because no swap is required
+        }
+
         template<typename T>
         void readBitsInternal(T &v, size_t size) {
             auto bitsLeft = size;
             T res{};
             while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, BITS_SIZE<value_type>);
+                auto bits = std::min(bitsLeft, details::BITS_SIZE<ValueType>);
                 if (m_scratchBits < bits) {
-                    value_type tmp;
-
-                    std::copy_n(_pos, 1, reinterpret_cast<value_type *>(&tmp));
-                    std::advance(_pos, 1);
-
-                    m_scratch |= static_cast<SCRATCH_TYPE>(tmp) << m_scratchBits;
-                    m_scratchBits += BITS_SIZE<value_type>;
+                    ValueType tmp;
+                    directRead(&tmp, 1);
+                    m_scratch |= static_cast<ScratchType>(tmp) << m_scratchBits;
+                    m_scratchBits += details::BITS_SIZE<ValueType>;
                 }
                 auto shiftedRes =
-                        static_cast<T>(m_scratch & ((static_cast<SCRATCH_TYPE>(1) << bits) - 1)) << (size - bitsLeft);
+                        static_cast<T>(m_scratch & ((static_cast<ScratchType>(1) << bits) - 1)) << (size - bitsLeft);
                 res |= shiftedRes;
                 m_scratch >>= bits;
                 m_scratchBits -= bits;
@@ -152,13 +167,12 @@ namespace bitsery {
             v = res;
         }
 
-        using SCRATCH_TYPE = typename BIGGER_TYPE<value_type>::type;
-
-        SCRATCH_TYPE m_scratch{};
+        ScratchType m_scratch{};
         size_t m_scratchBits{};                                    ///< Number of bits currently in the scratch buffer. If the user wants to read more bits than this, we have to go fetch another dword from memory.
 
     };
-
+    //helper type
+    using BufferReader = BasicBufferReader<DefaultConfig>;
 }
 
 #endif //BITSERY_BUFFER_READER_H

include/bitsery/buffer_writer.h

@@ -29,6 +29,7 @@
 #include <cassert>
 #include <algorithm>
 #include <iterator>
+#include <utility>
 
 namespace bitsery {
 
@@ -38,13 +39,13 @@ namespace bitsery {
         void writeBytes(const T &) {
             static_assert(std::is_integral<T>(), "");
             static_assert(sizeof(T) == SIZE, "");
-            _bitsCount += BITS_SIZE<T>;
+            _bitsCount += details::BITS_SIZE<T>;
         }
 
         template<typename T>
         void writeBits(const T &, size_t bitsCount) {
             static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            assert(bitsCount <= BITS_SIZE<T>);
+            assert(bitsCount <= details::BITS_SIZE<T>);
             _bitsCount += bitsCount;
         }
 
@@ -52,7 +53,7 @@ namespace bitsery {
         void writeBuffer(const T *, size_t count) {
             static_assert(std::is_integral<T>(), "");
             static_assert(sizeof(T) == SIZE, "");
-            _bitsCount += BITS_SIZE<T> * count;
+            _bitsCount += details::BITS_SIZE<T> * count;
         }
 
         //get size in bytes
@@ -65,24 +66,34 @@ namespace bitsery {
 
     };
 
+    template <typename Config>
+    struct BasicBufferWriter {
+        using ValueType = typename Config::BufferValueType;
+        using ScratchType = typename Config::BufferScrathType;
 
-    struct BufferWriter {
-        using value_type = uint8_t;
-
-        BufferWriter(std::vector<uint8_t> &buffer) : _buf{buffer}, _outIt{std::back_inserter(buffer)} {
-            static_assert(std::is_unsigned<value_type>::value, "");
+        explicit BasicBufferWriter(std::vector<ValueType> &buffer) : _outIt{std::back_inserter(buffer)} {
+            static_assert(std::is_unsigned<ValueType>(), "Config::BufferValueType must be unsigned");
+            static_assert(std::is_unsigned<ScratchType>(), "Config::BufferScrathType must be unsigned");
+            static_assert(sizeof(ValueType)*2 == sizeof(ScratchType), "ScratchType must be 2x bigger than value type");
+            static_assert(sizeof(ValueType) == 1, "currently only supported BufferValueType is 1 byte");
         }
 
+        BasicBufferWriter(const BasicBufferWriter&) = delete;
+        BasicBufferWriter& operator=(const BasicBufferWriter& ) = delete;
+        BasicBufferWriter(BasicBufferWriter&&) noexcept = default;
+        BasicBufferWriter& operator=(BasicBufferWriter&&) noexcept = default;
+        ~BasicBufferWriter() noexcept = default;
+
         template<size_t SIZE, typename T>
         void writeBytes(const T &v) {
             static_assert(std::is_integral<T>(), "");
             static_assert(sizeof(T) == SIZE, "");
 
-            if (!m_scratchBits) {
+            if (!_scratchBits) {
                 directWrite(&v, 1);
             } else {
                 using UT = typename std::make_unsigned<T>::type;
-                writeBits(reinterpret_cast<const UT &>(v), BITS_SIZE<T>);
+                writeBits(reinterpret_cast<const UT &>(v), details::BITS_SIZE<T>);
             }
         }
 
@@ -90,36 +101,36 @@ namespace bitsery {
         void writeBuffer(const T *buf, size_t count) {
             static_assert(std::is_integral<T>(), "");
             static_assert(sizeof(T) == SIZE, "");
-            if (!m_scratchBits) {
+            if (!_scratchBits) {
                 directWrite(buf, count);
             } else {
                 using UT = typename std::make_unsigned<T>::type;
                 //todo improve implementation
                 const auto end = buf + count;
                 for (auto it = buf; it != end; ++it)
-                    writeBits(reinterpret_cast<const UT &>(*it), BITS_SIZE<T>);
+                    writeBits(reinterpret_cast<const UT &>(*it), details::BITS_SIZE<T>);
             }
         }
 
         template<typename T>
         void writeBits(const T &v, size_t bitsCount) {
             static_assert(std::is_integral<T>() && std::is_unsigned<T>(), "");
-            assert(bitsCount <= BITS_SIZE<T>);
+            assert(0 < bitsCount && bitsCount <= details::BITS_SIZE<T>);
             assert(v <= ((1ULL << bitsCount) - 1));
             writeBitsInternal(v, bitsCount);
         }
 
         void align() {
-            if (m_scratchBits)
-                writeBitsInternal(value_type{}, BITS_SIZE<value_type> - m_scratchBits);
+            if (_scratchBits)
+                writeBitsInternal(ValueType{}, details::BITS_SIZE<ValueType> - _scratchBits);
         }
 
         void flush() {
-            if (m_scratchBits) {
-                auto tmp = static_cast<value_type>( m_scratch & bufTypeMask );
+            if (_scratchBits) {
+                auto tmp = static_cast<ValueType>( _scratch & _MASK );
                 directWrite(&tmp, 1);
-                m_scratch >>= m_scratchBits;
-                m_scratchBits -= m_scratchBits;
+                _scratch >>= _scratchBits;
+                _scratchBits -= _scratchBits;
             }
         }
 
@@ -127,57 +138,68 @@ namespace bitsery {
     private:
 
         template<typename T>
-        void directWrite(const T *v, size_t count) {
-            const auto bytesSize = sizeof(T) * count;
-            const auto pos = _buf.size();
-            _buf.resize(pos + bytesSize);
-            std::copy_n(reinterpret_cast<const value_type *>(v), bytesSize, _buf.data() + pos);
+        void directWrite(T&& v, size_t count) {
+            _directWriteSwapTag(std::forward<T>(v), count, std::integral_constant<bool,
+                    Config::NetworkEndianness != details::getSystemEndianness()>{});
+        }
+
+        template<typename T>
+        void _directWriteSwapTag(const T *v, size_t count, std::true_type) {
+            std::for_each(v, std::next(v, count), [this](const T& v) {
+                const auto res = details::swap(v);
+                std::copy_n(reinterpret_cast<const ValueType*>(&res), sizeof(T), _outIt);
+            });
+        }
+
+        template<typename T>
+        void _directWriteSwapTag(const T *v, size_t count, std::false_type) {
+            std::copy_n(reinterpret_cast<const ValueType*>(v), count * sizeof(T), _outIt);
         }
 
         template<typename T>
         void writeBitsInternal(const T &v, size_t size) {
+            constexpr size_t valueSize = details::BITS_SIZE<ValueType>;
             auto value = v;
             auto bitsLeft = size;
             while (bitsLeft > 0) {
-                auto bits = std::min(bitsLeft, BITS_SIZE<value_type>);
-                m_scratch |= static_cast<SCRATCH_TYPE>( value ) << m_scratchBits;
-                m_scratchBits += bits;
-                if (m_scratchBits >= BITS_SIZE<value_type>) {
-                    auto tmp = static_cast<value_type>(m_scratch & bufTypeMask);
+                auto bits = std::min(bitsLeft, valueSize);
+                _scratch |= static_cast<ScratchType>( value ) << _scratchBits;
+                _scratchBits += bits;
+                if (_scratchBits >= valueSize) {
+                    auto tmp = static_cast<ValueType>(_scratch & _MASK);
                     directWrite(&tmp, 1);
-                    m_scratch >>= BITS_SIZE<value_type>;
-                    m_scratchBits -= BITS_SIZE<value_type>;
+                    _scratch >>= valueSize;
+                    _scratchBits -= valueSize;
 
-                    value >>= BITS_SIZE<value_type>;
+                    value >>= valueSize;
                 }
                 bitsLeft -= bits;
             }
         }
-        void writeBitsInternal(const value_type &v, size_t size) {
+
+        //overload for ValueType, for better performance
+        void writeBitsInternal(const ValueType &v, size_t size) {
             if (size > 0) {
-                m_scratch |= static_cast<SCRATCH_TYPE>( v ) << m_scratchBits;
-                m_scratchBits += size;
-                if (m_scratchBits >= BITS_SIZE<value_type>) {
-                    auto tmp = static_cast<value_type>(m_scratch & bufTypeMask);
+                _scratch |= static_cast<ScratchType>( v ) << _scratchBits;
+                _scratchBits += size;
+                if (_scratchBits >= details::BITS_SIZE<ValueType>) {
+                    auto tmp = static_cast<ValueType>(_scratch & _MASK);
                     directWrite(&tmp, 1);
-                    m_scratch >>= BITS_SIZE<value_type>;
-                    m_scratchBits -= BITS_SIZE<value_type>;
+                    _scratch >>= details::BITS_SIZE<ValueType>;
+                    _scratchBits -= details::BITS_SIZE<ValueType>;
                 }
             }
         }
 
 
-        const value_type bufTypeMask = 0xFF;
-        using SCRATCH_TYPE = typename BIGGER_TYPE<value_type>::type;
-        std::vector<value_type> &_buf;
-        std::back_insert_iterator<std::vector<value_type>> _outIt;
-        SCRATCH_TYPE m_scratch{};
-        size_t m_scratchBits{};
-
-
-        //size_t _bufSize{};
-
+        const ValueType _MASK = std::numeric_limits<ValueType>::max();
+        std::back_insert_iterator<std::vector<ValueType>> _outIt;
+        ScratchType _scratch{};
+        size_t _scratchBits{};
     };
+
+    //helper type
+    using BufferWriter = BasicBufferWriter<DefaultConfig>;
 }
 
 #endif //BITSERY_BUFFER_WRITER_H

include/bitsery/common.h

@@ -21,218 +21,27 @@
 //SOFTWARE.
 
 
-
 #ifndef BITSERY_COMMON_H
 #define BITSERY_COMMON_H
 
-#include <cstdint>
+#include "bitsery/details/buffer_common.h"
 
 namespace bitsery {
 
-    template<typename T>
-    constexpr size_t BITS_SIZE = sizeof(T) << 3;
-
-    template<typename T>
-    struct BIGGER_TYPE {
+    struct DefaultConfig {
+        static constexpr EndiannessType NetworkEndianness = EndiannessType::LittleEndian;
+        using BufferValueType = uint8_t;
+        using BufferScrathType = uint16_t;
     };
 
-    template<>
-    struct BIGGER_TYPE<uint8_t> {
-        typedef uint16_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<uint16_t> {
-        typedef uint32_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<uint32_t> {
-        typedef uint64_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<int8_t> {
-        typedef int16_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<int16_t> {
-        typedef int32_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<int32_t> {
-        typedef int64_t type;
-    };
-
-    template<>
-    struct BIGGER_TYPE<char> {
-        typedef int16_t type;
-    };
-
-    template<typename T>
-    constexpr size_t ARITHMETIC_OR_ENUM_SIZE = std::is_arithmetic<T>::value || std::is_enum<T>::value ? sizeof(T) : 0;
-
-
-    template<typename T, typename Enable = void>
-    struct SAME_SIZE_UNSIGNED_TYPE {
-        typedef std::make_unsigned_t<T> type;
-    };
-
-    template<typename T>
-    struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_enum<T>::value>::type> {
-        typedef std::make_unsigned_t<std::underlying_type_t<T>> type;
-    };
-
-    template<typename T>
-    struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-        typedef std::conditional_t<std::is_same<T, float>::value, uint32_t, uint64_t> type;
-    };
-
-    template<typename T>
-    using SAME_SIZE_UNSIGNED = typename SAME_SIZE_UNSIGNED_TYPE<T>::type;
-
-
-    template<size_t SIZE>
-    struct ProcessAnyType {
-        template<typename S, typename T>
-        static void serialize(S &s, T &&v) {
-            s.template value<SIZE>(std::forward<T>(v));
-        }
-    };
-
-    template<>
-    struct ProcessAnyType<0> {
-        template<typename S, typename T>
-        static void serialize(S &s, T &&v) {
-            s.object(std::forward<T>(v));
-        }
-    };
+/*
+ * serializer macro, serialize function specialization that accepts T& and const T&
+ */
 
 
 #define SERIALIZE(ObjectType) \
 template <typename S, typename T, typename std::enable_if<std::is_same<T, ObjectType>::value || std::is_same<T, const ObjectType>::value>::type* = nullptr> \
 S& serialize(S& s, T& o)
 
-/*
- * range functions
- */
-
-    template<typename T>
-    constexpr size_t calcRequiredBits(T min, T max) {
-        size_t res{};
-        for (auto diff = max - min; diff > 0; diff >>= 1)
-            ++res;
-        return res;
-    }
-
-
-    template<typename T, typename Enable = void>
-    struct RangeSpec {
-
-        constexpr RangeSpec(T minValue, T maxValue)
-                : min{minValue},
-                  max{maxValue},
-                  bitsRequired{calcRequiredBits(min, max)} {
-        }
-
-        const T min;
-        const T max;
-        const size_t bitsRequired;
-    };
-
-
-    template<typename T>
-    struct RangeSpec<T, typename std::enable_if<std::is_enum<T>::value>::type> {
-
-        constexpr RangeSpec(T minValue, T maxValue) :
-                min{minValue},
-                max{maxValue},
-                bitsRequired{calcRequiredBits(
-                        static_cast<std::underlying_type_t<T>>(min),
-                        static_cast<std::underlying_type_t<T>>(max))} {
-        }
-
-        const T min;
-        const T max;
-        const size_t bitsRequired;
-    };
-
-//this class is used to make default RangeSpec float specialization always prefer constructor with precision
-    struct BitsConstraint {
-        explicit constexpr BitsConstraint(size_t bits) : value{bits} {}
-
-        const size_t value;
-    };
-
-    template<typename T>
-    struct RangeSpec<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-
-        constexpr RangeSpec(T minValue, T maxValue, BitsConstraint bits) :
-                min{minValue},
-                max{maxValue},
-                bitsRequired{bits.value} {
-        }
-
-        constexpr RangeSpec(T minValue, T maxValue, T precision) :
-                min{minValue},
-                max{maxValue},
-                bitsRequired{calcRequiredBits<SAME_SIZE_UNSIGNED<T>>({}, ((max - min) / precision))} {
-
-        }
-
-        const T min;
-        const T max;
-        const size_t bitsRequired;
-    };
-
-    template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type * = nullptr>
-    bool isRangeValid(const T &v, const RangeSpec<T> &r) {
-        return !(r.min > v || v > r.max);
-    }
-
-    template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-    bool isRangeValid(const T &v, const RangeSpec<T> &r) {
-        using VT = std::underlying_type_t<T>;
-        return !(static_cast<VT>(r.min) > static_cast<VT>(v)
-                 || static_cast<VT>(v) > static_cast<VT>(r.max));
-    }
-
-/*
- * delta functions
- */
-
-    class ObjectMemoryPosition {
-    public:
-
-        template<typename T>
-        ObjectMemoryPosition(const T &oldObj, const T &newObj)
-                :ObjectMemoryPosition{reinterpret_cast<const char *>(&oldObj), reinterpret_cast<const char *>(&newObj),
-                                      sizeof(T)} {
-        }
-
-        template<typename T>
-        bool isFieldsEquals(const T &newObjField) {
-            return *getOldObjectField(newObjField) == newObjField;
-        }
-
-        template<typename T>
-        const T *getOldObjectField(const T &field) {
-            auto offset = reinterpret_cast<const char *>(&field) - newObj;
-            return reinterpret_cast<const T *>(oldObj + offset);
-        }
-
-    private:
-
-        ObjectMemoryPosition(const char *objOld, const char *objNew, size_t)
-                : oldObj{objOld},
-                  newObj{objNew} {
-        }
-
-        const char *oldObj;
-        const char *newObj;
-    };
-
 }
 #endif //BITSERY_COMMON_H

include/bitsery/delta_deserializer.h

@@ -40,7 +40,7 @@ namespace bitsery {
                   _reader{r},
                   _oldObj{oldObj},
                   _newObj{newObj},
-                  _objMemPos(std::deque<ObjectMemoryPosition>(1, ObjectMemoryPosition{oldObj, newObj})),
+                  _objMemPos(std::deque<details::ObjectMemoryPosition>(1, details::ObjectMemoryPosition{oldObj, newObj})),
                   _isNewElement{false} {
         };
 
@@ -85,7 +85,7 @@ namespace bitsery {
                     processContainer(std::begin(old), std::end(old), std::begin(arr), std::end(arr), fnc);
                 } else {
                     for (auto &v:arr)
-                        fnc(v);
+                        fnc(*this, v);
                 }
             }
             return *this;
@@ -102,14 +102,14 @@ namespace bitsery {
                 } else {
                     T *tmp = arr;
                     for (auto i = 0u; i < N; ++i, ++tmp)
-                        fnc(*tmp);
+                        fnc(*this, *tmp);
                 }
             }
             return *this;
         }
 
         template<typename T, typename Fnc>
-        DeltaDeserializer &container(T &obj, Fnc &&fnc, size_t maxSize) {
+        DeltaDeserializer &container(T &obj, size_t maxSize, Fnc &&fnc) {
             if (getChangedState(obj)) {
                 size_t newSize{};
                 _reader.readBits(newSize, 32);
@@ -122,7 +122,7 @@ namespace bitsery {
                 } else {
                     obj.resize(newSize);
                     for (auto &v:obj)
-                        fnc(v);
+                        fnc(*this, v);
                 }
             }
             return *this;
@@ -134,7 +134,7 @@ namespace bitsery {
 
         const TObj &_oldObj;
         const TObj &_newObj;
-        std::stack<ObjectMemoryPosition> _objMemPos;
+        std::stack<details::ObjectMemoryPosition> _objMemPos;
         bool _isNewElement;
 
         template<typename T>
@@ -173,8 +173,8 @@ namespace bitsery {
                     *p = *pOld;
                     --offset;
                 } else {
-                    _objMemPos.emplace(ObjectMemoryPosition{*pOld, *p});
-                    fnc(*p);
+                    _objMemPos.emplace(details::ObjectMemoryPosition{*pOld, *p});
+                    fnc(*this, *p);
                     _objMemPos.pop();
                     offset = readIndexOffset();
                 }
@@ -183,7 +183,7 @@ namespace bitsery {
                 return false;
             _isNewElement = true;
             for (; p != end; ++p, --offset)
-                fnc(*p);
+                fnc(*this, *p);
             _isNewElement = false;
             return offset == 0;
 

include/bitsery/delta_serializer.h

@@ -40,7 +40,7 @@ namespace bitsery {
                   _writter{w},
                   _oldObj{oldObj},
                   _newObj{newObj},
-                  _objMemPos(std::deque<ObjectMemoryPosition>(1, ObjectMemoryPosition{oldObj, newObj})),
+                  _objMemPos(std::deque<details::ObjectMemoryPosition>(1, details::ObjectMemoryPosition{oldObj, newObj})),
                   _isNewElement{false} {
 
         };
@@ -88,7 +88,7 @@ namespace bitsery {
                     processContainer(std::begin(old), std::end(old), std::begin(arr), std::end(arr), fnc);
                 } else {
                     for (auto &v:arr)
-                        fnc(v);
+                        fnc(*this, v);
                 }
             }
             return *this;
@@ -105,14 +105,14 @@ namespace bitsery {
                 } else {
                     const T *tmp = arr;
                     for (auto i = 0u; i < N; ++i, ++tmp)
-                        fnc(*tmp);
+                        fnc(*this, *tmp);
                 }
             }
             return *this;
         }
 
         template<typename T, typename Fnc>
-        DeltaSerializer &container(T &&obj, Fnc &&fnc, size_t maxSize) {
+        DeltaSerializer &container(T &&obj, size_t maxSize, Fnc &&fnc) {
             if (setChangedState(obj)) {
                 _writter.writeBits(obj.size(), 32);
                 if (!_isNewElement) {
@@ -121,7 +121,7 @@ namespace bitsery {
                                      std::forward<Fnc>(fnc));
                 } else {
                     for (auto &v:obj)
-                        fnc(v);
+                        fnc(*this, v);
                 }
             }
             return *this;
@@ -132,7 +132,7 @@ namespace bitsery {
         Writter &_writter;
         const TObj &_oldObj;
         const TObj &_newObj;
-        std::stack<ObjectMemoryPosition> _objMemPos;
+        std::stack<details::ObjectMemoryPosition> _objMemPos;
         bool _isNewElement;
 
         template<typename T>
@@ -170,8 +170,8 @@ namespace bitsery {
             auto lastChanged = begin;
             while (misMatch.first != oldEnd && misMatch.second != end) {
                 writeIndexOffset(std::distance(lastChanged, misMatch.second));
-                _objMemPos.emplace(ObjectMemoryPosition{*misMatch.first, *misMatch.second});
-                fnc(*misMatch.second);
+                _objMemPos.emplace(details::ObjectMemoryPosition{*misMatch.first, *misMatch.second});
+                fnc(*this, *misMatch.second);
                 _objMemPos.pop();
                 ++misMatch.first;
                 ++misMatch.second;
@@ -183,15 +183,15 @@ namespace bitsery {
             writeIndexOffset(std::distance(lastChanged, end));
             //write old elements
             for (auto pOld = misMatch.first; p != end && pOld != oldEnd; ++p, ++pOld) {
-                _objMemPos.emplace(ObjectMemoryPosition{*pOld, *p});
-                fnc(*p);
+                _objMemPos.emplace(details::ObjectMemoryPosition{*pOld, *p});
+                fnc(*this, *p);
                 _objMemPos.pop();
             }
 
             //write new elements
             _isNewElement = true;
             for (; p != end; ++p)
-                fnc(*p);
+                fnc(*this, *p);
             _isNewElement = false;
         }
 

include/bitsery/deserializer.h

@@ -1,357 +1,379 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#ifndef BITSERY_DESERIALIZER_H
-#define BITSERY_DESERIALIZER_H
-
-#include "common.h"
-#include <array>
-#include <utility>
-
-namespace bitsery {
-
-    /*
-     * functions for range
-     */
-    template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-    void setRangeValue(T& v, const RangeSpec<T>& r) {
-        v += r.min;
-    };
-
-    template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
-    void setRangeValue(T& v, const RangeSpec<T>& r) {
-        using VT = std::underlying_type_t<T>;
-        reinterpret_cast<VT&>(v) += static_cast<VT>(r.min);
-    };
-
-    template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-    void setRangeValue(T& v, const RangeSpec<T>& r) {
-        using UIT = SAME_SIZE_UNSIGNED<T>;
-        const auto intRep = reinterpret_cast<UIT&>(v);
-        const UIT maxUint = (static_cast<UIT>(1) << r.bitsRequired) - 1;
-        v = r.min + (static_cast<T>(intRep) / maxUint) * (r.max - r.min);
-    };
-
-
-    template<typename Reader>
-    class Deserializer {
-    public:
-        Deserializer(Reader& r):_reader{r}, _isValid{true} {};
-
-        template <typename T>
-        Deserializer& object(T&& obj) {
-            return serialize(*this, std::forward<T>(obj));
-        }
-
-        /*
-         * value overloads
-         */
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-        Deserializer& value(T& v) {
-            static_assert(std::numeric_limits<float>::is_iec559, "");
-            static_assert(std::numeric_limits<double>::is_iec559, "");
-            if (_isValid) {
-                constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-                _isValid = _reader.template readBytes<ValueSize>(reinterpret_cast<SAME_SIZE_UNSIGNED<T>&>(v));
-            }
-            return *this;
-        }
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
-        Deserializer& value(T& v) {
-            constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-            using UT = std::underlying_type_t<T>;
-            if (_isValid) {
-                _isValid = _reader.template readBytes<ValueSize>(reinterpret_cast<UT&>(v));
-            }
-            return *this;
-        }
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-        Deserializer& value(T& v) {
-            constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-            if (_isValid) {
-                _isValid = _reader.template readBytes<ValueSize>(v);
-            }
-            return *this;
-        }
-
-        /*
-         * bool
-         */
-
-        Deserializer& boolBit(bool& v) {
-            if (_isValid) {
-                unsigned char tmp;
-                _isValid = _reader.readBits(tmp, 1);
-                v = tmp == 1;
-            }
-            return *this;
-        }
-
-        Deserializer& boolByte(bool& v) {
-            if (_isValid) {
-                unsigned char tmp;
-                _isValid = _reader.template readBytes<1>(tmp);
-                if (_isValid)
-                    _isValid = tmp < 2;
-                v = tmp == 1;
-            }
-            return *this;
-        }
-
-        /*
-         * range
-         */
-
-        template <typename T>
-        Deserializer& range(T& v, const RangeSpec<T>& range) {
-            if (_isValid) {
-                _isValid = _reader.template readBits(reinterpret_cast<SAME_SIZE_UNSIGNED<T>&>(v), range.bitsRequired);
-                setRangeValue(v, range);
-                if (_isValid)
-                    _isValid = isRangeValid(v, range);
-            }
-            return *this;
-        }
-
-        /*
-         * substitution overloads
-         */
-        template<typename T, size_t N, typename Fnc>
-        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues, Fnc&& fnc) {
-            size_t index;
-            range(index, {{}, N + 1});
-            if (_isValid) {
-                if (index)
-                    v = expectedValues[index-1];
-                else
-                    fnc(v);
-            }
-            return *this;
-        };
-
-        template<size_t VSIZE, typename T, size_t N>
-        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
-            size_t index;
-            range(index, {{}, N + 1});
-            if (_isValid) {
-                if (index)
-                    v = expectedValues[index-1];
-                else
-                    ProcessAnyType<VSIZE>::serialize(*this, v);
-            }
-            return *this;
-        };
-
-        template<typename T, size_t N>
-        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
-            size_t index;
-            range(index, {{}, N + 1});
-            if (_isValid) {
-                if (index)
-                    v = expectedValues[index-1];
-                else
-                    ProcessAnyType<ARITHMETIC_OR_ENUM_SIZE<T>>::serialize(*this, v);
-            }
-            return *this;
-        };
-
-        /*
-         * text overloads
-         */
-
-        template <size_t VSIZE = 1, typename T>
-        Deserializer& text(std::basic_string<T>& str, size_t maxSize) {
-            size_t size;
-            readSize(size, maxSize);
-            if (_isValid) {
-                str.resize(size);
-                if (size) {
-                    //if (std::is_const<decltype(std::declval<std::basic_string<T>>().data())>::value) {
-                        std::vector<T> buf(size);
-                        _isValid = _reader.template readBuffer<VSIZE>(buf.data(), size);
-                        str.assign(buf.data(), size);
-                    //} else {
-                        //_isValid = _reader.template readBuffer<VSIZE>(str.data(), size);
-                    //}
-                }
-            }
-            return *this;
-        }
-
-        template<size_t VSIZE=1, typename T, size_t N>
-        Deserializer& text(T (&str)[N]) {
-            size_t size;
-            readSize(size, N-1);
-            if (_isValid) {
-                _isValid = _reader.template readBuffer<VSIZE>(str, size);
-                str[size] = {};
-            }
-            return *this;
-        }
-
-        /*
-         * container overloads
-         */
-
-        template <typename T, typename Fnc>
-        Deserializer& container(T&& obj, Fnc&& fnc, size_t maxSize) {
-            decltype(obj.size()) size{};
-            readSize(size, maxSize);
-            if (_isValid) {
-                obj.resize(size);
-                for (auto& v:obj) {
-                    if (_isValid)
-                        fnc(v);
-                }
-
-            }
-            return *this;
-        }
-
-        template <size_t VSIZE, typename T>
-        Deserializer& container(T& obj, size_t maxSize) {
-            decltype(obj.size()) size{};
-            readSize(size, maxSize);
-            if (_isValid) {
-                obj.resize(size);
-                procContainer<VSIZE>(obj);
-            }
-            return *this;
-        }
-
-        template <typename T>
-        Deserializer& container(T& obj, size_t maxSize) {
-            decltype(obj.size()) size{};
-            readSize(size, maxSize);
-            if (_isValid) {
-                obj.resize(size);
-                procContainer<ARITHMETIC_OR_ENUM_SIZE<typename T::value_type>>(obj);
-            }
-            return *this;
-        }
-
-        /*
-         * array overloads (fixed size array (std::array, and c-style array))
-         */
-
-        //std::array overloads
-
-        template<typename T, size_t N, typename Fnc>
-        Deserializer&  array(std::array<T,N> &arr, Fnc && fnc) {
-            for (auto& v: arr)
-                if (_isValid)
-                    fnc(v);
-            return *this;
-        }
-
-        template<size_t VSIZE, typename T, size_t N>
-        Deserializer&  array(std::array<T,N> &arr) {
-            procContainer<VSIZE>(arr);
-            return *this;
-        }
-
-        template<typename T, size_t N>
-        Deserializer&  array(std::array<T,N> &arr) {
-            procContainer<ARITHMETIC_OR_ENUM_SIZE<T>>(arr);
-            return *this;
-        }
-
-        //c-style array overloads
-
-        template<typename T, size_t N, typename Fnc>
-        Deserializer& array(T (&arr)[N], Fnc&& fnc) {
-            T* tmp = arr;
-            for (auto i = 0u; i < N; ++i, ++tmp)
-                if (_isValid)
-                    fnc(*tmp);
-            return *this;
-        }
-
-        template<size_t VSIZE, typename T, size_t N>
-        Deserializer& array(T (&arr)[N]) {
-            procCArray<VSIZE>(arr);
-            return *this;
-        }
-
-        template<typename T, size_t N>
-        Deserializer& array(T (&arr)[N]) {
-            procCArray<ARITHMETIC_OR_ENUM_SIZE<T>>(arr);
-            return *this;
-        }
-        bool isValid() const {
-            return _isValid;
-        }
-
-    private:
-        Reader& _reader;
-        bool _isValid;
-        void readSize(size_t &size, size_t maxSize) {
-            size = {};
-            if (_isValid) {
-                unsigned char firstBit;
-                _isValid = _reader.readBits(firstBit, 1);
-                if (_isValid) {
-                    if (firstBit) {
-                        _isValid = _reader.readBits(size, 7);
-                    } else {
-                        unsigned char secondBit;
-                        _isValid = _reader.readBits(secondBit, 1);
-                        if (_isValid) {
-                            if (secondBit) {
-                                _isValid = _reader.readBits(size,14);
-                            } else {
-                                _isValid = _reader.readBits(size,30);
-                            }
-                        }
-                    }
-                }
-                if (_isValid)
-                    _isValid = size <= maxSize;
-            }
-        }
-        template <size_t VSIZE, typename T>
-        void procContainer(T&& obj) {
-            //todo could be improved for arithmetic types in contiguous containers (std::vector, std::array) (keep in mind std::vector<bool> specialization)
-            for (auto& v: obj)
-                if (_isValid)
-                    ProcessAnyType<VSIZE>::serialize(*this, v);
-        };
-
-        template <size_t VSIZE, typename T, size_t N>
-        void procCArray(T (&arr)[N]) {
-            //todo could be improved for arithmetic types
-            T* end = arr + N;
-            for (T* it = arr; it != end; ++it)
-                if (_isValid)
-                    ProcessAnyType<VSIZE>::serialize(*this, *it);
-        };
-
-    };
-
-
-}
-
-#endif //BITSERY_DESERIALIZER_H
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#ifndef BITSERY_DESERIALIZER_H
+#define BITSERY_DESERIALIZER_H
+
+#include "common.h"
+#include "details/serialization_common.h"
+#include <utility>
+
+namespace bitsery {
+
+
+    template<typename Reader>
+    class Deserializer {
+    public:
+        Deserializer(Reader& r):_reader{r}, _isValid{true} {};
+
+        template <typename T>
+        Deserializer& object(T&& obj) {
+            return serialize(*this, std::forward<T>(obj));
+        }
+
+        //in c++17 change "class" to typename
+        template <template <typename> class Extension, typename TValue, typename Fnc>
+        Deserializer& ext(TValue& v, Fnc&& fnc) {
+            static_assert(!std::is_const<TValue>(), "");
+            Extension<TValue> ext{v};
+            ext.deserialize(*this, std::forward<Fnc>(fnc));
+            return *this;
+        };
+
+        /*
+         * value overloads
+         */
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            static_assert(std::numeric_limits<T>::is_iec559, "");
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(reinterpret_cast<details::SAME_SIZE_UNSIGNED<T>&>(v));
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            using UT = std::underlying_type_t<T>;
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(reinterpret_cast<UT&>(v));
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+        Deserializer& value(T& v) {
+            if (_isValid) {
+                _isValid = _reader.template readBytes<VSIZE>(v);
+            }
+            return *this;
+        }
+
+        /*
+         * bool
+         */
+
+        Deserializer& boolBit(bool& v) {
+            if (_isValid) {
+                unsigned char tmp;
+                _isValid = _reader.readBits(tmp, 1);
+                v = tmp == 1;
+            }
+            return *this;
+        }
+
+        Deserializer& boolByte(bool& v) {
+            if (_isValid) {
+                unsigned char tmp;
+                _isValid = _reader.template readBytes<1>(tmp);
+                if (_isValid)
+                    _isValid = tmp < 2;
+                v = tmp == 1;
+            }
+            return *this;
+        }
+
+        /*
+         * range
+         */
+
+        template <typename T>
+        Deserializer& range(T& v, const RangeSpec<T>& range) {
+            if (_isValid) {
+                _isValid = _reader.readBits(reinterpret_cast<details::SAME_SIZE_UNSIGNED<T>&>(v), range.bitsRequired);
+                details::setRangeValue(v, range);
+                if (_isValid)
+                    _isValid = details::isRangeValid(v, range);
+            }
+            return *this;
+        }
+
+        /*
+         * substitution overloads
+         */
+        template<typename T, size_t N, typename Fnc>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues, Fnc&& fnc) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    fnc(*this, v);
+            }
+            return *this;
+        };
+
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    value<VSIZE>(v);
+            }
+            return *this;
+        };
+
+        template<typename T, size_t N>
+        Deserializer& substitution(T& v, const std::array<T,N>& expectedValues) {
+            size_t index;
+            range(index, {{}, N + 1});
+            if (_isValid) {
+                if (index)
+                    v = expectedValues[index-1];
+                else
+                    object(v);
+            }
+            return *this;
+        };
+
+        /*
+         * text overloads
+         */
+
+        template <size_t VSIZE, typename T>
+        Deserializer& text(std::basic_string<T>& str, size_t maxSize) {
+            size_t size;
+            readSize(size, maxSize);
+            if (_isValid) {
+                str.resize(size);
+                procContainer<VSIZE>(std::begin(str), std::end(str), std::true_type{});
+            }
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& text(T (&str)[N]) {
+            size_t size;
+            readSize(size, N-1);
+            if (_isValid) {
+                auto first = std::begin(str);
+                procContainer<VSIZE>(first, std::next(first, size), std::true_type{});
+                //null-terminated string
+                str[size] = {};
+            }
+            return *this;
+        }
+
+        /*
+         * container overloads
+         */
+
+        template <typename T, typename Fnc>
+        Deserializer& container(T&& obj, size_t maxSize, Fnc&& fnc) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+            }
+            return *this;
+        }
+
+        template <size_t VSIZE, typename T>
+        Deserializer& container(T& obj, size_t maxSize) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer<VSIZE>(std::begin(obj), std::end(obj), std::false_type{});
+            }
+            return *this;
+        }
+
+        template <typename T>
+        Deserializer& container(T& obj, size_t maxSize) {
+            decltype(obj.size()) size{};
+            readSize(size, maxSize);
+            if (_isValid) {
+                obj.resize(size);
+                procContainer(std::begin(obj), std::end(obj));
+            }
+            return *this;
+        }
+
+        /*
+         * array overloads (fixed size array (std::array, and c-style array))
+         */
+
+        //std::array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Deserializer&  array(std::array<T,N> &arr, Fnc && fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer&  array(std::array<T,N> &arr) {
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Deserializer&  array(std::array<T,N> &arr) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+
+        //c-style array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Deserializer& array(T (&arr)[N], Fnc&& fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Deserializer& array(T (&arr)[N]) {
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Deserializer& array(T (&arr)[N]) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+        bool isValid() const {
+            return _isValid;
+        }
+
+        Deserializer& align() {
+            _reader.align();
+            return *this;
+        }
+
+        //overloads for functions with explicit type size
+        template<typename T> Deserializer& value1(T &&v) { return value<1>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value2(T &&v) { return value<2>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value4(T &&v) { return value<4>(std::forward<T>(v)); }
+        template<typename T> Deserializer& value8(T &&v) { return value<8>(std::forward<T>(v)); }
+
+        template<typename T, size_t N> Deserializer& substitution1
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<1>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution2
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<2>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution4
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<4>(v, expectedValues); };
+        template<typename T, size_t N> Deserializer& substitution8
+                (T &v, const std::array<T, N> &expectedValues) { return substitution<8>(v, expectedValues); };
+
+        template<typename T> Deserializer& text1(std::basic_string<T> &str, size_t maxSize) {
+            return text<1>(str, maxSize); }
+        template<typename T> Deserializer& text2(std::basic_string<T> &str, size_t maxSize) {
+            return text<2>(str, maxSize); }
+        template<typename T> Deserializer& text4(std::basic_string<T> &str, size_t maxSize) {
+            return text<4>(str, maxSize); }
+
+        template<typename T, size_t N> Deserializer& text1(T (&str)[N]) { return text<1>(str); }
+        template<typename T, size_t N> Deserializer& text2(T (&str)[N]) { return text<2>(str); }
+        template<typename T, size_t N> Deserializer& text4(T (&str)[N]) { return text<4>(str); }
+
+        template<typename T> Deserializer& container1(T &&obj, size_t maxSize) {
+            return container<1>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container2(T &&obj, size_t maxSize) {
+            return container<2>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container4(T &&obj, size_t maxSize) {
+            return container<4>(std::forward<T>(obj), maxSize); }
+        template<typename T> Deserializer& container8(T &&obj, size_t maxSize) {
+            return container<8>(std::forward<T>(obj), maxSize); }
+
+    private:
+        Reader& _reader;
+        bool _isValid;
+        void readSize(size_t &size, size_t maxSize) {
+            size = {};
+            if (_isValid) {
+                unsigned char firstBit;
+                _isValid = _reader.readBits(firstBit, 1);
+                if (_isValid) {
+                    if (firstBit) {
+                        _isValid = _reader.readBits(size, 7);
+                    } else {
+                        unsigned char secondBit;
+                        _isValid = _reader.readBits(secondBit, 1);
+                        if (_isValid) {
+                            if (secondBit) {
+                                _isValid = _reader.readBits(size,14);
+                            } else {
+                                _isValid = _reader.readBits(size,30);
+                            }
+                        }
+                    }
+                }
+                if (_isValid)
+                    _isValid = size <= maxSize;
+            }
+        }
+
+        //process value types
+        //false_type means that we must process all elements individually
+        template<size_t VSIZE, typename It>
+        void procContainer(It first, It last, std::false_type) {
+            for (;_isValid && first != last; ++first)
+                value<VSIZE>(*first);
+        };
+
+        //process value types
+        //true_type means, that we can copy whole buffer
+        template<size_t VSIZE, typename It>
+        void procContainer(It first, It last, std::true_type) {
+            if (_isValid && first != last)
+                _isValid = _reader.template readBuffer<VSIZE>(&(*first), std::distance(first, last));
+        };
+
+        //process by calling functions
+        template<typename It, typename Fnc>
+        void procContainer(It first, It last, Fnc fnc) {
+            for (;_isValid && first != last; ++first)
+                fnc(*this, *first);
+        };
+
+        //process object types
+        template<typename It>
+        void procContainer(It first, It last) {
+            for (;_isValid && first != last; ++first)
+                object(*first);
+        };
+
+    };
+
+
+}
+
+#endif //BITSERY_DESERIALIZER_H

include/bitsery/details/buffer_common.h

@@ -0,0 +1,96 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+#ifndef BITSERY_BUFFER_COMMON_H
+#define BITSERY_BUFFER_COMMON_H
+
+namespace bitsery {
+
+/*
+ * endianess
+ */
+    enum class EndiannessType {
+        LittleEndian,
+        BigEndian
+    };
+
+    namespace details {
+        template<typename T>
+        constexpr size_t BITS_SIZE = sizeof(T) << 3;
+
+        //add swap functions to class, to avoid compilation warning about unused functions
+        struct swapImpl {
+            static uint64_t exec(uint64_t value) {
+#ifdef __GNUC__
+                return __builtin_bswap64( value );
+#else
+                value = ( value & 0x00000000FFFFFFFF ) << 32 | ( value & 0xFFFFFFFF00000000 ) >> 32;
+            value = ( value & 0x0000FFFF0000FFFF ) << 16 | ( value & 0xFFFF0000FFFF0000 ) >> 16;
+            value = ( value & 0x00FF00FF00FF00FF ) << 8  | ( value & 0xFF00FF00FF00FF00 ) >> 8;
+            return value;
+#endif
+            }
+
+            static uint32_t exec(uint32_t value)
+            {
+#ifdef __GNUC__
+                return __builtin_bswap32( value );
+#else
+                return ( value & 0x000000ff ) << 24 | ( value & 0x0000ff00 ) << 8 | ( value & 0x00ff0000 ) >> 8 | ( value & 0xff000000 ) >> 24;
+#endif
+            }
+
+            static uint16_t exec(uint16_t value)
+            {
+                return ( value & 0x00ff ) << 8 | ( value & 0xff00 ) >> 8;
+            }
+
+            static uint8_t exec(uint8_t value) {
+                return value;
+            }
+        };
+
+        template <typename TValue>
+        TValue swap(TValue value) {
+            constexpr size_t TSize = sizeof(TValue);
+            using UT = typename std::conditional<TSize == 1, uint8_t,
+                    typename std::conditional<TSize == 2, uint16_t,
+                            typename std::conditional<TSize == 4, uint32_t , uint64_t>::type>::type>::type;
+            return swapImpl::exec(static_cast<UT>(value));
+        }
+
+        //add test data in separate struct, because some compilers only support constexpr functions with return-only body
+        struct EndiannessTestData {
+            static constexpr uint32_t _sample4Bytes = 0x01020304;
+            static constexpr uint8_t _sample1stByte = (const uint8_t&)_sample4Bytes;
+        };
+
+        constexpr EndiannessType getSystemEndianness() {
+            static_assert(EndiannessTestData::_sample1stByte == 0x04 || EndiannessTestData::_sample1stByte == 0x01, "system must be either little or big endian");
+            return EndiannessTestData::_sample1stByte == 0x04 ? EndiannessType::LittleEndian : EndiannessType::BigEndian;
+        }
+
+    }
+}
+
+
+#endif //BITSERY_BUFFER_COMMON_H

include/bitsery/details/serialization_common.h

@@ -0,0 +1,239 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+#ifndef BITSERY_SERIALIZATION_COMMON_H
+#define BITSERY_SERIALIZATION_COMMON_H
+
+#include <cstdint>
+#include <type_traits>
+#include <array>
+
+namespace bitsery {
+
+    namespace details {
+
+        template<typename T, typename Enable = void>
+        struct SAME_SIZE_UNSIGNED_TYPE {
+            typedef std::make_unsigned_t<T> type;
+        };
+
+        template<typename T>
+        struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+            typedef std::make_unsigned_t<std::underlying_type_t<T>> type;
+        };
+
+        template<typename T>
+        struct SAME_SIZE_UNSIGNED_TYPE<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+            typedef std::conditional_t<std::is_same<T, float>::value, uint32_t, uint64_t> type;
+        };
+
+        template<typename T>
+        using SAME_SIZE_UNSIGNED = typename SAME_SIZE_UNSIGNED_TYPE<T>::type;
+
+        template <typename T>
+        constexpr size_t getSize(T v, size_t s) {
+            return v > 0 ? getSize(v / 2, s + 1) : s;
+        }
+
+        template<typename T>
+        constexpr size_t calcRequiredBits(T min, T max) {
+            //call recursive function, because some compilers only support constexpr functions with return-only body
+            return getSize(max - min, 0);
+        }
+
+    }
+
+/*
+ * range functions in bitsery namespace because these are used by user
+ */
+
+    template<typename T, typename Enable = void>
+    struct RangeSpec {
+
+        constexpr RangeSpec(T minValue, T maxValue)
+                : min{minValue},
+                  max{maxValue},
+                  bitsRequired{details::calcRequiredBits(min, max)} {
+        }
+
+        const T min;
+        const T max;
+        const size_t bitsRequired;
+    };
+
+
+    template<typename T>
+    struct RangeSpec<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+
+        constexpr RangeSpec(T minValue, T maxValue) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{details::calcRequiredBits(
+                        static_cast<std::underlying_type_t<T>>(min),
+                        static_cast<std::underlying_type_t<T>>(max))} {
+        }
+
+        const T min;
+        const T max;
+        const size_t bitsRequired;
+    };
+
+//this class is used to make default RangeSpec float specialization always prefer constructor with precision
+    struct BitsConstraint {
+        explicit constexpr BitsConstraint(size_t bits) : value{bits} {}
+
+        const size_t value;
+    };
+
+    template<typename T>
+    struct RangeSpec<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+
+        constexpr RangeSpec(T minValue, T maxValue, BitsConstraint bits) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{bits.value} {
+        }
+
+        constexpr RangeSpec(T minValue, T maxValue, T precision) :
+                min{minValue},
+                max{maxValue},
+                bitsRequired{details::calcRequiredBits<details::SAME_SIZE_UNSIGNED<T>>({}, ((max - min) / precision))} {
+
+        }
+
+        const T min;
+        const T max;
+        const size_t bitsRequired;
+    };
+
+    namespace details {
+
+/*
+ * functions for range
+ */
+
+        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            return static_cast<SAME_SIZE_UNSIGNED<T>>(v - r.min);
+        };
+
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            return static_cast<SAME_SIZE_UNSIGNED<T>>(v) - static_cast<SAME_SIZE_UNSIGNED<T>>(r.min);
+        };
+
+        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+        auto getRangeValue(const T &v, const RangeSpec<T> &r) {
+            using VT = SAME_SIZE_UNSIGNED<T>;
+            const VT maxUint = (static_cast<VT>(1) << r.bitsRequired) - 1;
+            const auto ratio = (v - r.min) / (r.max - r.min);
+            return static_cast<VT>(ratio * maxUint);
+        };
+
+        template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            v += r.min;
+        };
+
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            using VT = std::underlying_type_t<T>;
+            reinterpret_cast<VT&>(v) += static_cast<VT>(r.min);
+        };
+
+        template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+        void setRangeValue(T& v, const RangeSpec<T>& r) {
+            using UIT = SAME_SIZE_UNSIGNED<T>;
+            const auto intRep = reinterpret_cast<UIT&>(v);
+            const UIT maxUint = (static_cast<UIT>(1) << r.bitsRequired) - 1;
+            v = r.min + (static_cast<T>(intRep) / maxUint) * (r.max - r.min);
+        };
+
+        template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type * = nullptr>
+        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
+            return !(r.min > v || v > r.max);
+        }
+
+        template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        bool isRangeValid(const T &v, const RangeSpec<T> &r) {
+            using VT = std::underlying_type_t<T>;
+            return !(static_cast<VT>(r.min) > static_cast<VT>(v)
+                     || static_cast<VT>(v) > static_cast<VT>(r.max));
+        }
+
+/*
+ * functions for substitution
+ */
+
+        template<typename T, size_t N>
+        size_t findSubstitutionIndex(const T &v, const std::array<T, N> &defValues) {
+            auto index{1u};
+            for (auto &d:defValues) {
+                if (d == v)
+                    return index;
+                ++index;
+            }
+            return 0u;
+        };
+
+
+/*
+ * delta functions
+ */
+
+        class ObjectMemoryPosition {
+        public:
+
+            template<typename T>
+            ObjectMemoryPosition(const T &oldObj, const T &newObj)
+                    :ObjectMemoryPosition{reinterpret_cast<const char *>(&oldObj), reinterpret_cast<const char *>(&newObj),
+                                          sizeof(T)} {
+            }
+
+            template<typename T>
+            bool isFieldsEquals(const T &newObjField) {
+                return *getOldObjectField(newObjField) == newObjField;
+            }
+
+            template<typename T>
+            const T *getOldObjectField(const T &field) {
+                auto offset = reinterpret_cast<const char *>(&field) - newObj;
+                return reinterpret_cast<const T *>(oldObj + offset);
+            }
+
+        private:
+
+            ObjectMemoryPosition(const char *objOld, const char *objNew, size_t)
+                    : oldObj{objOld},
+                      newObj{objNew} {
+            }
+
+            const char *oldObj;
+            const char *newObj;
+        };
+
+
+    }
+
+}
+
+#endif //BITSERY_SERIALIZATION_COMMON_H

include/bitsery/ext/optional.h

@@ -0,0 +1,67 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#ifndef BITSERY_EXT_OPTIONAL_H
+#define BITSERY_EXT_OPTIONAL_H
+
+namespace bitsery {
+    namespace ext {
+
+        template <typename T>
+        using std_optional = ::std::optional<T>;
+
+        template <typename T>
+        class optional {
+        public:
+            explicit optional(T& v):_value{v} {
+                using TOpt = typename std::remove_cv<T>::type;
+                using TVal = typename TOpt::value_type;
+                static_assert(std::is_same<TOpt, std_optional<TVal>>(), "");
+            };
+            template <typename TSerializer, typename Fnc>
+            void serialize(TSerializer& ser, const Fnc& fnc) {
+                ser.boolByte(static_cast<bool>(_value));
+                if (_value)
+                    fnc(ser, *_value);
+            }
+            template <typename TSerializer, typename Fnc>
+            void deserialize(TSerializer& ser, const Fnc& fnc) {
+                bool exists{};
+                ser.boolByte(exists);
+                if (exists) {
+                    typename T::value_type tmp{};
+                    fnc(ser, tmp);
+                    _value = tmp;
+                } else {
+                    _value = T{};
+                }
+            }
+        private:
+            T& _value;
+        };
+
+    }
+}
+
+
+#endif //BITSERY_EXT_OPTIONAL_H

include/bitsery/serializer.h

@@ -1,300 +1,330 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-
-#ifndef BITSERY_SERIALIZER_H
-#define BITSERY_SERIALIZER_H
-
-#include "common.h"
-#include <array>
-
-namespace bitsery {
-
-/*
- * functions for range
- */
-
-    template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
-    auto getRangeValue(const T &v, const RangeSpec<T> &r) {
-        return static_cast<SAME_SIZE_UNSIGNED<T>>(v - r.min);
-    };
-
-    template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-    auto getRangeValue(const T &v, const RangeSpec<T> &r) {
-        return static_cast<SAME_SIZE_UNSIGNED<T>>(v) - static_cast<SAME_SIZE_UNSIGNED<T>>(r.min);
-    };
-
-    template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
-    auto getRangeValue(const T &v, const RangeSpec<T> &r) {
-        using VT = SAME_SIZE_UNSIGNED<T>;
-        const VT maxUint = (static_cast<VT>(1) << r.bitsRequired) - 1;
-        const auto ratio = (v - r.min) / (r.max - r.min);
-        return static_cast<VT>(ratio * maxUint);
-    };
-
-/*
- * functions for substitution
- */
-
-    template<typename T, size_t N>
-    size_t findSubstitutionIndex(const T &v, const std::array<T, N> &defValues) {
-        auto index{1u};
-        for (auto &d:defValues) {
-            if (d == v)
-                return index;
-            ++index;
-        }
-        return 0u;
-    };
-
-
-
-
-    template<typename Writter>
-    class Serializer {
-    public:
-        Serializer(Writter &w) : _writter{w} {};
-
-        template<typename T>
-        Serializer& object(const T &obj) {
-            return serialize(*this, obj);
-        }
-
-        /*
-         * value overloads
-         */
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
-        Serializer& value(const T &v) {
-            static_assert(std::numeric_limits<float>::is_iec559, "");
-            static_assert(std::numeric_limits<double>::is_iec559, "");
-
-            constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-            _writter.template writeBytes<ValueSize>(reinterpret_cast<const SAME_SIZE_UNSIGNED<T> &>(v));
-            return *this;
-        }
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
-        Serializer& value(const T &v) {
-            constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-            _writter.template writeBytes<ValueSize>(reinterpret_cast<const std::underlying_type_t<T> &>(v));
-            return *this;
-        }
-
-        template<size_t VSIZE = 0, typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
-        Serializer& value(const T &v) {
-            constexpr size_t ValueSize = VSIZE == 0 ? sizeof(T) : VSIZE;
-            _writter.template writeBytes<ValueSize>(v);
-            return *this;
-        }
-
-        /*
-         * bool
-         */
-
-        Serializer& boolBit(bool v) {
-            _writter.template writeBits(static_cast<unsigned char>(v ? 1 : 0), 1);
-            return *this;
-        }
-
-        Serializer& boolByte(bool v) {
-            _writter.template writeBytes<1>(static_cast<unsigned char>(v ? 1 : 0));
-            return *this;
-        }
-
-        /*
-         * range
-         */
-
-        template<typename T>
-        Serializer& range(const T &v, const RangeSpec<T> &range) {
-            assert(isRangeValid(v, range));
-            _writter.template writeBits(getRangeValue(v, range), range.bitsRequired);
-            return *this;
-        }
-
-        /*
-         * substitution overloads
-         */
-        template<typename T, size_t N, typename Fnc>
-        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues, Fnc &&fnc) {
-            auto index = findSubstitutionIndex(v, expectedValues);
-            range(index, {{}, N +1});
-            if (!index)
-                fnc(v);
-            return *this;
-        };
-
-        template<size_t VSIZE, typename T, size_t N>
-        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
-            auto index = findSubstitutionIndex(v, expectedValues);
-            range(index, {{}, N +1});
-            if (!index)
-                ProcessAnyType<VSIZE>::serialize(*this, v);
-            return *this;
-        };
-
-        template<typename T, size_t N>
-        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
-            auto index = findSubstitutionIndex(v, expectedValues);
-            range(index, {{}, N +1});
-            if (!index)
-                ProcessAnyType<ARITHMETIC_OR_ENUM_SIZE<T>>::serialize(*this, v);
-            return *this;
-        };
-
-        /*
-         * text overloads
-         */
-
-        template<size_t VSIZE = 1, typename T>
-        Serializer& text(const std::basic_string<T> &str, size_t maxSize) {
-            assert(str.size() <= maxSize);
-            procText<VSIZE>(str.data(), str.size());
-            return *this;
-        }
-
-        template<size_t VSIZE = 1, typename T, size_t N>
-        Serializer& text(const T (&str)[N]) {
-            procText<VSIZE>(str, std::min(std::char_traits<T>::length(str), N - 1));
-            return *this;
-        }
-
-        /*
-         * container overloads
-         */
-
-        template<typename T, typename Fnc>
-        Serializer& container(const T &obj, Fnc &&fnc, size_t maxSize) {
-            assert(obj.size() <= maxSize);
-            writeSize(obj.size());
-            for (auto &v: obj)
-                fnc(v);
-            return *this;
-        }
-
-        template<size_t VSIZE, typename T>
-        Serializer& container(const T &obj, size_t maxSize) {
-            assert(obj.size() <= maxSize);
-            writeSize(obj.size());
-            procContainer<VSIZE>(obj);
-            return *this;
-        }
-
-        template<typename T>
-        Serializer& container(const T &obj, size_t maxSize) {
-            assert(obj.size() <= maxSize);
-            writeSize(obj.size());
-            procContainer<ARITHMETIC_OR_ENUM_SIZE<typename T::value_type>>(obj);
-            return *this;
-        }
-
-        /*
-         * array overloads (fixed size array (std::array, and c-style array))
-         */
-
-        //std::array overloads
-
-        template<typename T, size_t N, typename Fnc>
-        Serializer& array(const std::array<T, N> &arr, Fnc &&fnc) {
-            for (auto &v: arr)
-                fnc(v);
-            return *this;
-        }
-
-        template<size_t VSIZE, typename T, size_t N>
-        Serializer& array(const std::array<T, N> &arr) {
-            procContainer<VSIZE>(arr);
-            return *this;
-        }
-
-        template<typename T, size_t N>
-        Serializer& array(const std::array<T, N> &arr) {
-            procContainer<ARITHMETIC_OR_ENUM_SIZE<T>>(arr);
-            return *this;
-        }
-
-        //c-style array overloads
-
-        template<typename T, size_t N, typename Fnc>
-        Serializer& array(const T (&arr)[N], Fnc &&fnc) {
-            const T *end = arr + N;
-            for (const T *tmp = arr; tmp != end; ++tmp)
-                fnc(*tmp);
-            return *this;
-        }
-
-        template<size_t VSIZE, typename T, size_t N>
-        Serializer& array(const T (&arr)[N]) {
-            procCArray<VSIZE>(arr);
-            return *this;
-        }
-
-        template<typename T, size_t N>
-        Serializer& array(const T (&arr)[N]) {
-            procCArray<ARITHMETIC_OR_ENUM_SIZE<T>>(arr);
-            return *this;
-        }
-
-    private:
-        Writter &_writter;
-
-        void writeSize(const size_t size) {
-            if (size < 0x80u) {
-                _writter.writeBits(1u, 1);
-                _writter.writeBits(size, 7);
-            } else if (size < 0x4000u) {
-                _writter.writeBits(2u,2);
-                _writter.writeBits(size, 14);
-            } else {
-                assert(size < 0x40000000u);
-                _writter.writeBits(0u,2);
-                _writter.writeBits(size, 30);
-            }
-        }
-
-        template<size_t VSIZE, typename T>
-        void procContainer(T &&obj) {
-            //todo could be improved for arithmetic types in contiguous containers (std::vector, std::array) (keep in mind std::vector<bool> specialization)
-            for (auto &v: obj)
-                ProcessAnyType<VSIZE>::serialize(*this, v);
-        };
-
-        template<size_t VSIZE, typename T, size_t N>
-        void procCArray(T (&arr)[N]) {
-            //todo could be improved for arithmetic types
-            const T *end = arr + N;
-            for (const T *it = arr; it != end; ++it)
-                ProcessAnyType<VSIZE>::serialize(*this, *it);
-        };
-
-        template<size_t VSIZE, typename T>
-        void procText(const T *str, size_t size) {
-            writeSize(size);
-            if (size)
-                _writter.template writeBuffer<VSIZE>(str, size);
-        }
-    };
-
-}
-#endif //BITSERY_SERIALIZER_H
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+
+#ifndef BITSERY_SERIALIZER_H
+#define BITSERY_SERIALIZER_H
+
+#include "common.h"
+#include <array>
+#include "details/serialization_common.h"
+
+namespace bitsery {
+
+    template<typename Writter>
+    class Serializer {
+    public:
+        Serializer(Writter &w) : _writter{w} {};
+
+        template<typename T>
+        Serializer& object(const T &obj) {
+            return serialize(*this, obj);
+        }
+
+        //in c++17 change "class" to typename
+        template <template <typename> class Extension, typename TValue, typename Fnc>
+        Serializer& ext(const TValue& v, Fnc&& fnc ) {
+            Extension<const TValue> ext{v};
+            ext.serialize(*this, std::forward<Fnc>(fnc));
+            return *this;
+        };
+
+
+        /*
+         * value overloads
+         */
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            static_assert(std::numeric_limits<T>::is_iec559, "");
+            _writter.template writeBytes<VSIZE>(reinterpret_cast<const details::SAME_SIZE_UNSIGNED<T> &>(v));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            _writter.template writeBytes<VSIZE>(reinterpret_cast<const std::underlying_type_t<T> &>(v));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+        Serializer& value(const T &v) {
+            _writter.template writeBytes<VSIZE>(v);
+            return *this;
+        }
+
+        /*
+         * bool
+         */
+
+        Serializer& boolBit(bool v) {
+            _writter.writeBits(static_cast<unsigned char>(v ? 1 : 0), 1);
+            return *this;
+        }
+
+        Serializer& boolByte(bool v) {
+            _writter.template writeBytes<1>(static_cast<unsigned char>(v ? 1 : 0));
+            return *this;
+        }
+
+        /*
+         * range
+         */
+
+        template<typename T>
+        Serializer& range(const T &v, const RangeSpec<T> &range) {
+            assert(details::isRangeValid(v, range));
+            _writter.template writeBits<decltype(details::getRangeValue(v, range))>(details::getRangeValue(v, range), range.bitsRequired);
+            return *this;
+        }
+
+        /*
+         * substitution overloads
+         */
+        template<typename T, size_t N, typename Fnc>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues, Fnc &&fnc) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                fnc(*this, v);
+            return *this;
+        };
+
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                value<VSIZE>(v);
+            return *this;
+        };
+
+        template<typename T, size_t N>
+        Serializer& substitution(const T &v, const std::array<T, N> &expectedValues) {
+            auto index = details::findSubstitutionIndex(v, expectedValues);
+            range(index, {{}, N +1});
+            if (!index)
+                object(v);
+            return *this;
+        };
+
+        /*
+         * text overloads
+         */
+
+        template<size_t VSIZE, typename T>
+        Serializer& text(const std::basic_string<T> &str, size_t maxSize) {
+            assert(str.size() <= maxSize);
+            auto first = std::begin(str);
+            auto last = std::end(str);
+            writeSize(std::distance(first, last));
+            procContainer<VSIZE>(first, last, std::true_type{});
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& text(const T (&str)[N]) {
+            auto first = std::begin(str);
+            auto last = std::next(first, std::min(std::char_traits<T>::length(str), N - 1));
+            writeSize(std::distance(first, last));
+            procContainer<VSIZE>(first, last, std::true_type{});
+            return *this;
+        }
+
+        /*
+         * container overloads
+         */
+
+        template<typename T, typename Fnc>
+        Serializer& container(const T &obj, size_t maxSize, Fnc &&fnc) {
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
+            procContainer(std::begin(obj), std::end(obj), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T>
+        Serializer& container(const T &obj, size_t maxSize) {
+            static_assert(VSIZE > 0, "");
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
+            //todo optimisation is possible for contigous containers, but currently there is no compile-time check for this
+            procContainer<VSIZE>(std::begin(obj), std::end(obj), std::false_type{});
+            return *this;
+        }
+
+        template<typename T>
+        Serializer& container(const T &obj, size_t maxSize) {
+            assert(obj.size() <= maxSize);
+            writeSize(obj.size());
+            procContainer(std::begin(obj), std::end(obj));
+            return *this;
+        }
+
+        /*
+         * array overloads (fixed size array (std::array, and c-style array))
+         */
+
+        //std::array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Serializer& array(const std::array<T, N> &arr, Fnc &&fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& array(const std::array<T, N> &arr) {
+            static_assert(VSIZE > 0, "");
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Serializer& array(const std::array<T, N> &arr) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+
+        //c-style array overloads
+
+        template<typename T, size_t N, typename Fnc>
+        Serializer& array(const T (&arr)[N], Fnc &&fnc) {
+            procContainer(std::begin(arr), std::end(arr), std::forward<Fnc>(fnc));
+            return *this;
+        }
+
+        template<size_t VSIZE, typename T, size_t N>
+        Serializer& array(const T (&arr)[N]) {
+            static_assert(VSIZE > 0, "");
+            procContainer<VSIZE>(std::begin(arr), std::end(arr), std::true_type{});
+            return *this;
+        }
+
+        template<typename T, size_t N>
+        Serializer& array(const T (&arr)[N]) {
+            procContainer(std::begin(arr), std::end(arr));
+            return *this;
+        }
+
+        Serializer& align() {
+            _writter.align();
+            return *this;
+        }
+
+        //overloads for functions with explicit type size
+        template<typename T> Serializer& value1(T &&v) { return value<1>(std::forward<T>(v)); }
+        template<typename T> Serializer& value2(T &&v) { return value<2>(std::forward<T>(v)); }
+        template<typename T> Serializer& value4(T &&v) { return value<4>(std::forward<T>(v)); }
+        template<typename T> Serializer& value8(T &&v) { return value<8>(std::forward<T>(v)); }
+
+        template<typename T, size_t N> Serializer& substitution1
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<1>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution2
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<2>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution4
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<4>(v, expectedValues); };
+        template<typename T, size_t N> Serializer& substitution8
+                (const T &v, const std::array<T, N> &expectedValues) { return substitution<8>(v, expectedValues); };
+
+        template<typename T> Serializer& text1(const std::basic_string<T> &str, size_t maxSize) {
+            return text<1>(str, maxSize); }
+        template<typename T> Serializer& text2(const std::basic_string<T> &str, size_t maxSize) {
+            return text<2>(str, maxSize); }
+        template<typename T> Serializer& text4(const std::basic_string<T> &str, size_t maxSize) {
+            return text<4>(str, maxSize); }
+
+        template<typename T, size_t N> Serializer& text1(const T (&str)[N]) { return text<1>(str); }
+        template<typename T, size_t N> Serializer& text2(const T (&str)[N]) { return text<2>(str); }
+        template<typename T, size_t N> Serializer& text4(const T (&str)[N]) { return text<4>(str); }
+
+        template<typename T> Serializer& container1(T &&obj, size_t maxSize) {
+            return container<1>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container2(T &&obj, size_t maxSize) {
+            return container<2>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container4(T &&obj, size_t maxSize) {
+            return container<4>(std::forward<T>(obj), maxSize); }
+        template<typename T> Serializer& container8(T &&obj, size_t maxSize) {
+            return container<8>(std::forward<T>(obj), maxSize); }
+
+        template<typename T, size_t N> Serializer& array1(const std::array<T, N> &arr) { return array<1>(arr); }
+        template<typename T, size_t N> Serializer& array2(const std::array<T, N> &arr) { return array<2>(arr); }
+        template<typename T, size_t N> Serializer& array4(const std::array<T, N> &arr) { return array<4>(arr); }
+        template<typename T, size_t N> Serializer& array8(const std::array<T, N> &arr) { return array<8>(arr); }
+
+        template<typename T, size_t N> Serializer& array1(const T (&arr)[N]) { return array<1>(arr); }
+        template<typename T, size_t N> Serializer& array2(const T (&arr)[N]) { return array<2>(arr); }
+        template<typename T, size_t N> Serializer& array4(const T (&arr)[N]) { return array<4>(arr); }
+        template<typename T, size_t N> Serializer& array8(const T (&arr)[N]) { return array<8>(arr); }
+
+    private:
+        Writter &_writter;
+
+        void writeSize(const size_t size) {
+            if (size < 0x80u) {
+                _writter.writeBits(1u, 1);
+                _writter.writeBits(size, 7);
+            } else if (size < 0x4000u) {
+                _writter.writeBits(2u,2);
+                _writter.writeBits(size, 14);
+            } else {
+                assert(size < 0x40000000u);
+                _writter.writeBits(0u,2);
+                _writter.writeBits(size, 30);
+            }
+        }
+
+        //process value types
+        //false_type means that we must process all elements individually
+        template<size_t VSIZE, typename It>
+        void procContainer(It first, It last, std::false_type) {
+            for (;first != last; ++first)
+                value<VSIZE>(*first);
+        };
+
+        //process value types
+        //true_type means, that we can copy whole buffer
+        template<size_t VSIZE, typename It>
+        void procContainer(It first, It last, std::true_type) {
+            if (first != last)
+                _writter.template writeBuffer<VSIZE>(&(*first), std::distance(first, last));
+        };
+
+        //process by calling functions
+        template<typename It, typename Fnc>
+        void procContainer(It first, It last, Fnc fnc) {
+            for (;first != last; ++first)
+                fnc(*this, *first);
+        };
+
+        //process object types
+        template<typename It>
+        void procContainer(It first, It last) {
+            for (;first != last; ++first)
+                object(*first);
+        };
+
+    };
+
+}
+#endif //BITSERY_SERIALIZER_H

tests/CMakeLists.txt

@@ -21,77 +21,54 @@
 #SOFTWARE.
 
 cmake_minimum_required(VERSION 3.2)
-project(${TEST_PROJECT_NAME} C CXX)
+set(TestProjectName bitsery_tests)
+project(${TestProjectName} C CXX)
+
 
 find_package(Threads REQUIRED)
 
 #add googletest external project
 #USE_GMOCK enable gmock
 #exports variables GTEST_INCLUDE_DIRS, GTEST_LIBS_DIR, GTEST_LIBNAME, GTEST_MAIN_LIBNAME
-set(EXT_PROJECTS_DIR ${CMAKE_SOURCE_DIR}/ext)
-set(USE_GMOCK ON)
-add_subdirectory(${EXT_PROJECTS_DIR}/gtest ${CMAKE_BINARY_DIR}/gtest)
+set(ExtCMakeFilesDir ${CMAKE_SOURCE_DIR}/ext)
+set(UseGMock ON)
+add_subdirectory(${ExtCMakeFilesDir}/gtest ${CMAKE_BINARY_DIR}/gtest)
 
+#this helps idea to know which files are actually used
+file(GLOB_RECURSE IncludeHeaders ${CMAKE_SOURCE_DIR}/include/bitsery/*.h)
 # set common include folder for module
-include_directories(SYSTEM ${GTEST_INCLUDE_DIRS})
+include_directories(SYSTEM ${GTestIncludeDirs})
 include_directories(${CMAKE_SOURCE_DIR}/include)
 
-file(GLOB TEST_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB TestSourceFiles ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 
-FOREACH(TEST_PROJECT_FILE ${TEST_SRC_FILES})
-    get_filename_component(SEPARATE_TEST_NAME ${TEST_PROJECT_FILE} NAME_WE)
-    set(SEPARATE_TEST_NAME TEST_${SEPARATE_TEST_NAME})
-    add_executable(${SEPARATE_TEST_NAME} ${TEST_PROJECT_FILE})
-    add_dependencies(${SEPARATE_TEST_NAME} googletest)
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    message(WARNING "extension tests for optional is disable for VS, because VS currenty doesn't have <optional>")
+    list(REMOVE_ITEM TestSourceFiles ${CMAKE_CURRENT_SOURCE_DIR}/serialization_ext_optional.cpp)
+endif()
 
-    set_property(TARGET ${SEPARATE_TEST_NAME} PROPERTY CXX_STANDARD 14)
-    set_property(TARGET ${SEPARATE_TEST_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
+include(${ExtCMakeFilesDir}/LinkTestLib.cmake)
 
+FOREACH(TestFile ${TestSourceFiles})
+    get_filename_component(TestName ${TestFile} NAME_WE)
+    set(TestName TEST_${TestName})
+    add_executable(${TestName} ${TestFile} ${IncludeHeaders})
+    LinkTestLib(${TestName})
 
-    if(NOT WIN32 OR MINGW)
-        FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
-            target_link_libraries(${SEPARATE_TEST_NAME} ${GTEST_LIBS_DIR}/lib${LIBNAME}.a )
-        ENDFOREACH()
-    else()
-        FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
-            target_link_libraries(${SEPARATE_TEST_NAME}
-                    debug ${GTEST_LIBS_DIR}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES}
-                    optimized ${GTEST_LIBS_DIR}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES})
-        ENDFOREACH()
-    endif()
-
-    target_link_libraries(${SEPARATE_TEST_NAME} ${CMAKE_THREAD_LIBS_INIT})
-
-    add_test(NAME ${SEPARATE_TEST_NAME} COMMAND $<TARGET_FILE:${SEPARATE_TEST_NAME}>)
+    add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)
 
 ENDFOREACH()
 
 #all in one tests for code coverage
-add_executable(${TEST_PROJECT_NAME} ${TEST_SRC_FILES})
-add_dependencies(${TEST_PROJECT_NAME} googletest)
+add_executable(${TestProjectName} ${TestSourceFiles})
 
-set_property(TARGET ${TEST_PROJECT_NAME} PROPERTY CXX_STANDARD 14)
-set_property(TARGET ${TEST_PROJECT_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
-
-
-if(NOT WIN32 OR MINGW)
-    FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
-        target_link_libraries(${TEST_PROJECT_NAME} ${GTEST_LIBS_DIR}/lib${LIBNAME}.a )
-    ENDFOREACH()
-else()
-    FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
-        target_link_libraries(${TEST_PROJECT_NAME}
-                debug ${GTEST_LIBS_DIR}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES}
-                optimized ${GTEST_LIBS_DIR}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES})
-    ENDFOREACH()
+if(CMAKE_COMPILER_IS_GNUCXX)
+    include(${ExtCMakeFilesDir}/CodeCoverage.cmake)
+    target_compile_options(${TestProjectName} PUBLIC -O0 -fprofile-arcs -ftest-coverage)
+    target_link_libraries(${TestProjectName} -O0 -fprofile-arcs -ftest-coverage)
+    setup_target_for_coverage(tests_coverage ${TestProjectName} coverage)
 endif()
 
-target_link_libraries(${TEST_PROJECT_NAME} ${CMAKE_THREAD_LIBS_INIT})
-
-
-
-
-
-
+LinkTestLib(${TestProjectName})
 
 

tests/buffer_bits_op.cpp

@@ -24,13 +24,13 @@
 #include <gmock/gmock.h>
 #include <bitsery/buffer_writer.h>
 #include <bitsery/buffer_reader.h>
-#include <list>
-#include <bitset>
+#include <bitsery/details/serialization_common.h>
 
 using testing::Eq;
 using testing::ContainerEq;
 using bitsery::BufferWriter;
 using bitsery::BufferReader;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
 
 struct IntegralUnsignedTypes {
     uint32_t a;
@@ -40,23 +40,29 @@ struct IntegralUnsignedTypes {
     uint64_t e;
 };
 
+template <typename T>
+constexpr size_t getBits(T v) {
+    return bitsery::details::calcRequiredBits<T>({}, v);
+};
+
 TEST(BufferBitsOperations, WriteAndReadBits) {
     //setup data
-    IntegralUnsignedTypes data;
-    data.a = 485454;//bits 19
-    data.b = 45978;//bits 16
-    data.c = 0;//bits 1
-    data.d = 36;//bits 6
-    data.e = 479845648946;//bits 39
+    constexpr IntegralUnsignedTypes data{
+        485454,//bits 19
+        45978,//bits 16
+        0,//bits 1
+        36,//bits 6
+        479845648946//bits 39
+    };
 
-    constexpr size_t aBITS = 21;
-    constexpr size_t bBITS = 16;
-    constexpr size_t cBITS = 5;
-    constexpr size_t dBITS = 7;
-    constexpr size_t eBITS = 40;
+    constexpr size_t aBITS = getBits(data.a) + 2;
+    constexpr size_t bBITS = getBits(data.b) + 0;
+    constexpr size_t cBITS = getBits(data.c) + 2;
+    constexpr size_t dBITS = getBits(data.d) + 1;
+    constexpr size_t eBITS = getBits(data.e) + 8;
 
     //create and write to buffer
-    std::vector<uint8_t> buf;
+    Buffer buf;
     BufferWriter bw{buf};
 
     bw.writeBits(data.a, aBITS);
@@ -87,7 +93,7 @@ TEST(BufferBitsOperations, WriteAndReadBits) {
 
 TEST(BufferBitsOperations, WhenFinishedFlushWriter) {
 
-    std::vector<uint8_t> buf;
+    Buffer buf;
     BufferWriter bw{buf};
 
     bw.writeBits(3u, 2);
@@ -101,7 +107,7 @@ TEST(BufferBitsOperations, BufferSizeIsCountedPerByteNotPerBit) {
     //setup data
 
     //create and write to buffer
-    std::vector<uint8_t> buf;
+    Buffer buf;
     BufferWriter bw{buf};
 
     bw.writeBits(7u,3);
@@ -110,7 +116,7 @@ TEST(BufferBitsOperations, BufferSizeIsCountedPerByteNotPerBit) {
 
     //read from buffer
     BufferReader br{buf};
-    unsigned tmp;
+    uint16_t tmp;
     EXPECT_THAT(br.readBits(tmp,4), Eq(true));
     EXPECT_THAT(br.readBits(tmp,2), Eq(true));
     EXPECT_THAT(br.readBits(tmp,2), Eq(true));
@@ -126,11 +132,44 @@ TEST(BufferBitsOperations, BufferSizeIsCountedPerByteNotPerBit) {
     EXPECT_THAT(br2.readBits(tmp,9), Eq(false));
 }
 
+TEST(BufferBitsOperations, ConsecutiveCallsToAlignHasNoEffect) {
+    Buffer buf;
+    BufferWriter bw{buf};
+
+    bw.writeBits(3u, 2);
+    //3 calls to align after 1st data
+    bw.align();
+    bw.align();
+    bw.align();
+    bw.writeBits(7u, 3);
+    //1 call to align after 2nd data
+    bw.align();
+    bw.writeBits(15u, 4);
+    bw.flush();
+
+    unsigned char tmp;
+    BufferReader br{buf};
+    EXPECT_THAT(br.readBits(tmp,2), Eq(true));
+    EXPECT_THAT(tmp, Eq(3u));
+    EXPECT_THAT(br.align(), Eq(true));
+
+    EXPECT_THAT(br.readBits(tmp,3), Eq(true));
+    EXPECT_THAT(tmp, Eq(7u));
+    EXPECT_THAT(br.align(), Eq(true));
+    EXPECT_THAT(br.align(), Eq(true));
+    EXPECT_THAT(br.align(), Eq(true));
+
+    EXPECT_THAT(br.readBits(tmp,4), Eq(true));
+    EXPECT_THAT(tmp, Eq(15u));
+}
+
+
+
 TEST(BufferBitsOperations, WhenAlignedFlushHasNoEffect) {
     //setup data
 
     //create and write to buffer
-    std::vector<uint8_t> buf;
+    Buffer buf;
     BufferWriter bw{buf};
 
     bw.writeBits(3u, 2);
@@ -140,11 +179,12 @@ TEST(BufferBitsOperations, WhenAlignedFlushHasNoEffect) {
     EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
 }
 
+
 TEST(BufferBitsOperations, AlignMustWriteZerosBits) {
     //setup data
 
     //create and write to buffer
-    std::vector<uint8_t> buf;
+    Buffer buf;
     BufferWriter bw{buf};
 
     //write 2 bits and align

tests/buffer_bytes_op.cpp

@@ -31,6 +31,7 @@ using testing::Eq;
 using testing::ContainerEq;
 using bitsery::BufferWriter;
 using bitsery::BufferReader;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
 
 struct IntegralTypes {
     int64_t a;
@@ -68,7 +69,7 @@ TEST(BufferBytesOperations, WriteAndReadBytes) {
     //setup data
     auto data =getInitializedIntegralTypes();
     //create and write to buffer
-    std::vector<uint8_t> buf{};
+    Buffer buf{};
     BufferWriter bw{buf};
     writeIntegralTypesToBuffer(bw, data);
 
@@ -98,7 +99,7 @@ TEST(BufferBytesOperations, BufferReaderUsingDataPlusSizeCtor) {
     //setup data
     auto data =getInitializedIntegralTypes();
     //create and write to buffer
-    std::vector<uint8_t> buf{};
+    Buffer buf{};
     BufferWriter bw{buf};
     writeIntegralTypesToBuffer(bw, data);
 
@@ -127,7 +128,7 @@ TEST(BufferBytesOperations, BufferReaderUsingCArrayCtor) {
     //setup data
     auto data =getInitializedIntegralTypes();
     //create and write to buffer
-    std::vector<uint8_t> buf{};
+    Buffer buf{};
     BufferWriter bw{buf};
     writeIntegralTypesToBuffer(bw, data);
 
@@ -161,7 +162,7 @@ TEST(BufferBytesOperations, ReadReturnsFalseIfNotEnoughBufferSize) {
     uint8_t a = 111;
 
     //create and write to buffer
-    std::vector<uint8_t> buf{};
+    Buffer buf{};
     BufferWriter bw{buf};
 
     bw.writeBytes<1>(a);
@@ -190,7 +191,7 @@ TEST(BufferBytesOperations, ReadIsCompletedWhenAllBytesAreRead) {
     data.d = 200;
 
     //create and write to buffer
-    std::vector<uint8_t> buf{};
+    Buffer buf{};
     BufferWriter bw{buf};
 
     bw.writeBytes<4>(data.b);
@@ -217,3 +218,57 @@ TEST(BufferBytesOperations, ReadIsCompletedWhenAllBytesAreRead) {
     EXPECT_THAT(br1.isCompleted(), Eq(true));
 
 }
+
+TEST(BufferBytesOperations, ReadWriteBufferFncCanAcceptSignedData) {
+    //setup data
+    constexpr size_t DATA_SIZE = 3;
+    int16_t src[DATA_SIZE] {54,-4877,30067};
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    bw.writeBuffer<2>(src, DATA_SIZE);
+    bw.flush();
+    //read from buffer
+    BufferReader br1{buf};
+    int16_t dst[DATA_SIZE]{};
+    EXPECT_THAT(br1.readBuffer<2>(dst, DATA_SIZE), Eq(true));
+    EXPECT_THAT(dst, ContainerEq(src));
+
+    //read more than available
+    BufferReader br2{buf};
+    int16_t dstMore[DATA_SIZE+1]{};
+    EXPECT_THAT(br2.readBuffer<2>(dstMore, DATA_SIZE+1), Eq(false));
+}
+
+TEST(BufferBytesOperations, ReadWriteBufferCanWorkOnUnalignedData) {
+    //setup data
+    constexpr size_t DATA_SIZE = 3;
+    int16_t src[DATA_SIZE] {54,-4877,30067};
+    //create and write to buffer
+    Buffer buf{};
+    BufferWriter bw{buf};
+    bw.writeBits(15u, 4);
+    bw.writeBuffer<2>(src, DATA_SIZE);
+    bw.writeBits(12u, 4);
+    bw.flush();
+    EXPECT_THAT(buf.size(), Eq(sizeof(src) + 1));
+
+    //read from buffer
+    BufferReader br1{buf};
+    int16_t dst[DATA_SIZE]{};
+    uint8_t tmp{};
+    br1.readBits(tmp, 4);
+    EXPECT_THAT(tmp, Eq(15));
+    EXPECT_THAT(br1.readBuffer<2>(dst, DATA_SIZE), Eq(true));
+    EXPECT_THAT(dst, ContainerEq(src));
+    br1.readBits(tmp, 4);
+    EXPECT_THAT(tmp, Eq(12));
+
+    //read more than available
+    BufferReader br2{buf};
+    br2.readBits(tmp, 4);
+    int16_t dstMore[DATA_SIZE+1]{};
+    EXPECT_THAT(tmp, Eq(15));
+    EXPECT_THAT(br2.readBuffer<2>(dstMore, DATA_SIZE+1), Eq(false));
+}
+

tests/buffer_endianness.cpp

@@ -0,0 +1,183 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#include <gmock/gmock.h>
+#include <bitsery/buffer_writer.h>
+#include <bitsery/buffer_reader.h>
+#include <bitsery/details/serialization_common.h>
+
+using testing::Eq;
+using testing::ContainerEq;
+using bitsery::EndiannessType;
+using bitsery::DefaultConfig;
+using Buffer = std::vector<bitsery::DefaultConfig::BufferValueType>;
+
+constexpr EndiannessType getInverseEndianness(EndiannessType e) {
+    return e == EndiannessType::LittleEndian
+           ? EndiannessType::BigEndian
+           : EndiannessType::LittleEndian;
+}
+
+struct InverseEndiannessConfig {
+    static constexpr bitsery::EndiannessType NetworkEndianness = getInverseEndianness(DefaultConfig::NetworkEndianness);
+    using BufferValueType = DefaultConfig::BufferValueType;
+    using BufferScrathType = DefaultConfig::BufferScrathType;
+};
+
+struct IntegralTypes {
+    int64_t a;
+    uint32_t b;
+    int16_t c;
+    uint8_t d;
+    int8_t e;
+};
+
+
+TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
+    //fill initial values
+    IntegralTypes src{};
+    src.a = 0x1122334455667788;
+    src.b = 0xBBCCDDEE;
+    src.c = 0xCCDD;
+    src.d = 0xDD;
+    src.e = 0xEE;
+
+    //fill expected result after swap
+    IntegralTypes resInv{};
+    resInv.a = 0x8877665544332211;
+    resInv.b = 0xEEDDCCBB;
+    resInv.c = 0xDDCC;
+    resInv.d = 0xDD;
+    resInv.e = 0xEE;
+
+    //create and write to buffer
+    Buffer buf{};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
+    bw.writeBytes<8>(src.a);
+    bw.writeBytes<4>(src.b);
+    bw.writeBytes<2>(src.c);
+    bw.writeBytes<1>(src.d);
+    bw.writeBytes<1>(src.e);
+    bw.flush();
+    //read from buffer using inverse endianness config
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
+    IntegralTypes res{};
+    br.readBytes<8>(res.a);
+    br.readBytes<4>(res.b);
+    br.readBytes<2>(res.c);
+    br.readBytes<1>(res.d);
+    br.readBytes<1>(res.e);
+    //check results
+    EXPECT_THAT(res.a, Eq(resInv.a));
+    EXPECT_THAT(res.b, Eq(resInv.b));
+    EXPECT_THAT(res.c, Eq(resInv.c));
+    EXPECT_THAT(res.d, Eq(resInv.d));
+    EXPECT_THAT(res.e, Eq(resInv.e));
+}
+
+TEST(BufferEndianness, WhenWriteBuffer1ByteValuesThenEndiannessIsIgnored) {
+    //fill initial values
+    constexpr size_t SIZE = 4;
+    uint8_t src[SIZE] = {0xAA, 0xBB, 0xCC, 0xDD};
+    uint8_t res[SIZE] = {};
+    //create and write to buffer
+    Buffer buf{};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
+    bw.writeBuffer<1>(src, SIZE);
+    bw.flush();
+    //read from buffer using inverse endianness config
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
+    br.readBuffer<1>(res, SIZE);
+    //result is identical, because we write separate values, of size 1byte, that requires no swapping
+    //check results
+    EXPECT_THAT(res, ContainerEq(src));
+}
+
+TEST(BufferEndianness, WhenWriteBufferMoreThan1ByteValuesThenValuesAreSwapped) {
+    //fill initial values
+    constexpr size_t SIZE = 4;
+    uint16_t src[SIZE] = {0xAA00, 0xBB11, 0xCC22, 0xDD33};
+    uint16_t resInv[SIZE] = {0x00AA, 0x11BB, 0x22CC, 0x33DD};
+    uint16_t res[SIZE] = {};
+    //create and write to buffer
+    Buffer buf{};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
+    bw.writeBuffer<2>(src, SIZE);
+    bw.flush();
+    //read from buffer using inverse endianness config
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
+    br.readBuffer<2>(res, SIZE);
+    //result is identical, because we write separate values, of size 1byte, that requires no swapping
+    //check results
+    EXPECT_THAT(res, ContainerEq(resInv));
+}
+
+
+template <typename T>
+constexpr size_t getBits(T v) {
+    return bitsery::details::calcRequiredBits<T>({}, v);
+};
+
+struct IntegralUnsignedTypes {
+    uint64_t a;
+    uint32_t b;
+    uint16_t c;
+    uint8_t d;
+};
+
+TEST(BufferEndianness, WhenBufferValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
+    //fill initial values
+    static_assert(sizeof(DefaultConfig::BufferValueType) == 1, "currently only 1 byte size, value size is supported");
+    //fill initial values
+    constexpr IntegralUnsignedTypes src {
+            0x0000334455667788,//bits 19
+            0x00CCDDEE,//bits 16
+            0x00DD,//bits 1
+            0x0F,//bits 6
+    };
+
+    constexpr size_t aBITS = getBits(src.a) + 8;
+    constexpr size_t bBITS = getBits(src.b) + 0;
+    constexpr size_t cBITS = getBits(src.c) + 5;
+    constexpr size_t dBITS = getBits(src.d) + 2;
+    //create and write to buffer
+    Buffer buf{};
+    bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
+    bw.writeBits(src.a, aBITS);
+    bw.writeBits(src.b, bBITS);
+    bw.writeBits(src.c, cBITS);
+    bw.writeBits(src.d, dBITS);
+    bw.flush();
+    //read from buffer using inverse endianness config
+    bitsery::BasicBufferReader<InverseEndiannessConfig> br{buf};
+    IntegralUnsignedTypes res{};
+    br.readBits(res.a, aBITS);
+    br.readBits(res.b, bBITS);
+    br.readBits(res.c, cBITS);
+    br.readBits(res.d, dBITS);
+    //check results
+    EXPECT_THAT(res.a, Eq(src.a));
+    EXPECT_THAT(res.b, Eq(src.b));
+    EXPECT_THAT(res.c, Eq(src.c));
+    EXPECT_THAT(res.d, Eq(src.d));
+}

tests/serialization_container.cpp

@@ -1,168 +1,169 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <numeric>
-#include <deque>
-#include <list>
-
-using testing::ContainerEq;
-using testing::Eq;
-
-template <typename Container>
-Container getFilledContainer() {
-    return {1,2,3,4,5,78,456,8,54};
-}
-
-template <typename T>
-class SerializeContainerArthmeticTypes:public testing::Test {
-public:
-    using TContainer = T;
-    using TValue = typename T::value_type;
-
-    const TContainer src= getFilledContainer<TContainer>() ;
-    TContainer res{};
-
-    size_t getExpectedBufSize(const SerializationContext& ctx) const {
-        return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * sizeof(TValue);
-    }
-};
-//std::forward_list is not supported, because it doesn't have size() method
-using SequenceContainersWithArthmeticTypes = ::testing::Types<
-        std::vector<int>,
-        std::list<float>,
-        std::deque<unsigned short>>;
-
-TYPED_TEST_CASE(SerializeContainerArthmeticTypes, SequenceContainersWithArthmeticTypes);
-
-TYPED_TEST(SerializeContainerArthmeticTypes, Values) {
-    SerializationContext ctx{};
-
-    ctx.createSerializer().container(this->src, 1000);
-    ctx.createDeserializer().container(this->res, 1000);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
-    EXPECT_THAT(this->res, ContainerEq(this->src));
-}
-
-TYPED_TEST(SerializeContainerArthmeticTypes, ValuesWithExplicitSize) {
-    SerializationContext ctx{};
-    using TValue = typename TestFixture::TValue;
-
-    ctx.createSerializer().container<sizeof(TValue)>(this->src, 1000);
-    ctx.createDeserializer().container<sizeof(TValue)>(this->res, 1000);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
-    EXPECT_THAT(this->res, ContainerEq(this->src));
-}
-
-TYPED_TEST(SerializeContainerArthmeticTypes, CustomFunctionIncrements) {
-    SerializationContext ctx{};
-
-    auto ser = ctx.createSerializer();
-    ser.container(this->src, [&ser](auto v ) {
-        //increment by 1 before writing
-        v++;
-        ser.value(v);
-    }, 1000);
-    auto des = ctx.createDeserializer();
-    des.container(this->res, [&des](auto&v ) {
-        des.value(v);
-        //increment by 1 after reading
-        v++;
-    }, 1000);
-    //decrement result by 2, before comparing for eq
-    for(auto& v:this->res)
-        v -= 2;
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
-    EXPECT_THAT(this->res, ContainerEq(this->src));
-}
-
-
-
-
-template <typename T>
-class SerializeContainerCompositeTypes:public testing::Test {
-public:
-    using TContainer = T;
-    using TValue = typename T::value_type;
-
-    const TContainer src= getFilledContainer<TContainer>();
-    TContainer res{};
-    size_t getExpectedBufSize(const SerializationContext& ctx) const {
-        return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * TValue::SIZE;
-    }
-};
-
-template <>
-std::vector<MyStruct1> getFilledContainer<std::vector<MyStruct1>>() {
-    return {
-            {0,1},
-            {2,3},
-            {4,5},
-            {6,7},
-            {8,9},
-            {11,34},
-            {5134,1532}
-    };
-}
-
-template <>
-std::list<MyStruct2> getFilledContainer<std::list<MyStruct2>>() {
-    return {
-            {MyStruct2::V1, {0,1}} ,
-            {MyStruct2::V3, {-45,45}}
-    };
-}
-
-using SequenceContainersWithCompositeTypes = ::testing::Types<
-        std::vector<MyStruct1>,
-        std::list<MyStruct2>>;
-
-TYPED_TEST_CASE(SerializeContainerCompositeTypes, SequenceContainersWithCompositeTypes);
-
-TYPED_TEST(SerializeContainerCompositeTypes, DefaultSerializeFunction) {
-    SerializationContext ctx{};
-
-    ctx.createSerializer().container(this->src, 1000);
-    ctx.createDeserializer().container(this->res, 1000);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
-    EXPECT_THAT(this->res, ContainerEq(this->src));
-}
-
-
-TYPED_TEST(SerializeContainerCompositeTypes, CustomFunctionThatDoNothing) {
-    SerializationContext ctx{};
-
-    auto emptyFnc = [](auto v) {};
-    ctx.createSerializer().container(this->src, emptyFnc, 1000);
-    ctx.createDeserializer().container(this->res, emptyFnc, 1000);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(this->src.size())));
-}
-
-
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+#include <numeric>
+#include <deque>
+#include <list>
+
+using testing::ContainerEq;
+using testing::Eq;
+
+
+/*
+ * overload to get container of types
+ */
+
+template <typename Container>
+Container getFilledContainer() {
+    return {1,2,3,4,5,78,456,8,54};
+}
+
+template <>
+std::vector<MyStruct1> getFilledContainer<std::vector<MyStruct1>>() {
+    return {
+            {0,1},
+            {2,3},
+            {4,5},
+            {6,7},
+            {8,9},
+            {11,34},
+            {5134,1532}
+    };
+}
+
+template <>
+std::list<MyStruct2> getFilledContainer<std::list<MyStruct2>>() {
+    return {
+            {MyStruct2::V1, {0,1}} ,
+            {MyStruct2::V3, {-45,45}}
+    };
+}
+
+/*
+ * start testing session
+ */
+
+template <typename T>
+class SerializeContainerArthmeticTypes:public testing::Test {
+public:
+    using TContainer = T;
+    using TValue = typename T::value_type;
+
+    const TContainer src= getFilledContainer<TContainer>() ;
+    TContainer res{};
+
+    size_t getExpectedBufSize(const SerializationContext& ctx) const {
+        return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * sizeof(TValue);
+    }
+};
+//std::forward_list is not supported, because it doesn't have size() method
+using SequenceContainersWithArthmeticTypes = ::testing::Types<
+        std::vector<int>,
+        std::list<float>,
+        std::deque<unsigned short>>;
+
+TYPED_TEST_CASE(SerializeContainerArthmeticTypes, SequenceContainersWithArthmeticTypes);
+
+TYPED_TEST(SerializeContainerArthmeticTypes, Values) {
+    SerializationContext ctx{};
+    using TValue = typename TestFixture::TValue;
+
+    ctx.createSerializer().container<sizeof(TValue)>(this->src, 1000);
+    ctx.createDeserializer().container<sizeof(TValue)>(this->res, 1000);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
+    EXPECT_THAT(this->res, ContainerEq(this->src));
+}
+
+TYPED_TEST(SerializeContainerArthmeticTypes, CustomFunctionIncrements) {
+    SerializationContext ctx{};
+
+    auto ser = ctx.createSerializer();
+    ser.container(this->src, 1000, [](auto &s, auto v) {
+        //increment by 1 before writing
+        v++;
+        s.template value<sizeof(v)>(v);
+    });
+    auto des = ctx.createDeserializer();
+    des.container(this->res, 1000, [](auto &s, auto&v ) {
+        s.template value<sizeof(v)>(v);
+        //increment by 1 after reading
+        v++;
+    });
+    //decrement result by 2, before comparing for eq
+    for(auto& v:this->res)
+        v -= 2;
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
+    EXPECT_THAT(this->res, ContainerEq(this->src));
+}
+
+
+
+
+template <typename T>
+class SerializeContainerCompositeTypes:public testing::Test {
+public:
+    using TContainer = T;
+    using TValue = typename T::value_type;
+
+    const TContainer src= getFilledContainer<TContainer>();
+    TContainer res{};
+    size_t getExpectedBufSize(const SerializationContext& ctx) const {
+        return ctx.containerSizeSerializedBytesCount(src.size()) + src.size() * TValue::SIZE;
+    }
+};
+
+
+using SequenceContainersWithCompositeTypes = ::testing::Types<
+        std::vector<MyStruct1>,
+        std::list<MyStruct2>>;
+
+TYPED_TEST_CASE(SerializeContainerCompositeTypes, SequenceContainersWithCompositeTypes);
+
+TYPED_TEST(SerializeContainerCompositeTypes, DefaultSerializeFunction) {
+    SerializationContext ctx{};
+
+    ctx.createSerializer().container(this->src, 1000);
+    ctx.createDeserializer().container(this->res, 1000);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(this->getExpectedBufSize(ctx)));
+    EXPECT_THAT(this->res, ContainerEq(this->src));
+}
+
+
+TYPED_TEST(SerializeContainerCompositeTypes, CustomFunctionThatDoNothing) {
+    SerializationContext ctx{};
+
+
+    auto emptyFnc = [](auto& s, auto& v) {};
+    ctx.createSerializer().container(this->src, 1000, emptyFnc);
+    ctx.createDeserializer().container(this->res, 1000, emptyFnc);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(this->src.size())));
+}
+
+

tests/serialization_ext_optional.cpp

@@ -0,0 +1,86 @@
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+
+#if __cplusplus > 201402L
+#  include<optional>
+#else
+#  include <experimental/optional>
+    namespace std {
+        template <typename T>
+        using optional = experimental::optional<T>;
+    }
+#endif
+
+#include <bitsery/ext/optional.h>
+
+
+template <typename T>
+using extoptional = bitsery::ext::optional<T>;
+
+using testing::Eq;
+
+
+template <typename T>
+void test(SerializationContext& ctx, const T& v, T& r) {
+    auto fnc = [](auto ser, auto& v) {
+        ser.template value<sizeof(v)>(v);
+    };
+    ctx.createSerializer().ext<extoptional>(v, fnc);
+    ctx.createDeserializer().ext<extoptional>(r, fnc);
+}
+
+TEST(SerializeExtensionOptional, EmptyOptional) {
+    std::optional<int> t1{};
+    std::optional<int> r1{};
+
+    SerializationContext ctx1;
+    test(ctx1,t1, r1);
+    EXPECT_THAT(ctx1.getBufferSize(), Eq(1));
+    EXPECT_THAT(t1, Eq(r1));
+
+
+    r1 = 3;
+    SerializationContext ctx2;
+    test(ctx2,t1, r1);
+    EXPECT_THAT(ctx2.getBufferSize(), Eq(1));
+    EXPECT_THAT(t1, Eq(r1));
+}
+
+TEST(SerializeExtensionOptional, OptionalHasValue) {
+    std::optional<int> t1{43};
+    std::optional<int> r1{52};
+
+    SerializationContext ctx1;
+    test(ctx1,t1, r1);
+    EXPECT_THAT(ctx1.getBufferSize(), Eq(1 + sizeof(int)));
+    EXPECT_THAT(t1.value(), Eq(r1.value()));
+
+    r1 = std::optional<int>{};
+    SerializationContext ctx2;
+    test(ctx2,t1, r1);
+    EXPECT_THAT(ctx2.getBufferSize(), Eq(1 + sizeof(int)));
+    EXPECT_THAT(t1.value(), Eq(r1.value()));
+
+}

tests/serialization_fixed_size_array.cpp

@@ -1,158 +1,131 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-#include <type_traits>
-
-using testing::ContainerEq;
-using testing::Eq;
-
-TEST(SerializeFSArrayStdArray, ArithmeticValues) {
-    SerializationContext ctx;
-    std::array<int, 4> src{5,9,15,-459};
-    std::array<int, 4> res{};
-
-    ctx.createSerializer().array(src);
-    ctx.createDeserializer().array(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * sizeof(int)));
-    EXPECT_THAT(res, ContainerEq(src));
-
-}
-
-TEST(SerializeFSArrayStdArray, ArithmeticValuesSettingValueSizeExplicitly) {
-    SerializationContext ctx;
-    std::array<int, 4> src{5,9,15,-459};
-    std::array<int, 4> res{};
-
-    ctx.createSerializer().array<sizeof(int)>(src);
-    ctx.createDeserializer().array<sizeof(int)>(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * sizeof(int)));
-    EXPECT_THAT(res, ContainerEq(src));
-
-}
-
-TEST(SerializeFSArrayStdArray, CompositeTypes) {
-    SerializationContext ctx;
-    std::array<MyStruct1, 7> src{
-            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
-            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
-    std::array<MyStruct1, 7> res{};
-
-    ctx.createSerializer().array(src);
-    ctx.createDeserializer().array(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * MyStruct1::SIZE));
-    EXPECT_THAT(res, ContainerEq(src));
-}
-//
-//
-TEST(SerializeFSArrayStdArray, CustomFunctionThatSerializesAnEmptyByteEveryElement) {
-    SerializationContext ctx;
-    std::array<MyStruct1, 7> src{
-            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
-            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
-    std::array<MyStruct1, 7> res{};
-
-
-    auto ser = ctx.createSerializer();
-    ser.array(src, [&ser](auto& v) {
-        char tmp{};
-        ser.object(v).value(tmp);
-    });
-    auto des = ctx.createDeserializer();
-    des.array(res, [&des](auto& v) {
-        char tmp{};
-        des.object(v).value(tmp);
-    });
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * (MyStruct1::SIZE + sizeof(char))));
-    EXPECT_THAT(res, ContainerEq(src));
-}
-
-
-TEST(SerializeFSArrayCArray, ArithmeticValues) {
-    SerializationContext ctx;
-    int src[4]{5,9,15,-459};
-    int res[4]{};
-
-    ctx.createSerializer().array(src);
-    ctx.createDeserializer().array(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * sizeof(int)));
-    EXPECT_THAT(res, ContainerEq(src));
-
-}
-
-TEST(SerializeFSArrayCArray, ArithmeticValuesSettingValueSizeExplicitly) {
-    SerializationContext ctx;
-    int src[4]{5,9,15,-459};
-    int res[4]{};
-
-    ctx.createSerializer().array<sizeof(int)>(src);
-    ctx.createDeserializer().array<sizeof(int)>(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * sizeof(int)));
-    EXPECT_THAT(res, ContainerEq(src));
-
-}
-
-TEST(SerializeFSArrayCArray, CompositeTypes) {
-    SerializationContext ctx;
-    MyStruct1 src[]{
-            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
-            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
-    MyStruct1 res[7]{};
-
-    ctx.createSerializer().array(src);
-    ctx.createDeserializer().array(res);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * MyStruct1::SIZE));
-    EXPECT_THAT(res, ContainerEq(src));
-}
-//
-//
-TEST(SerializeFSArrayCArray, CustomFunctionThatSerializesAnEmptyByteEveryElement) {
-    SerializationContext ctx;
-    MyStruct1 src[]{
-            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
-            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
-    MyStruct1 res[7]{};
-
-
-    auto ser = ctx.createSerializer();
-    ser.array(src, [&ser](auto& v) {
-        char tmp{};
-        ser.object(v).value(tmp);
-    });
-    auto des = ctx.createDeserializer();
-    des.array(res, [&des](auto& v) {
-        char tmp{};
-        des.object(v).value(tmp);
-    });
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * (MyStruct1::SIZE + sizeof(char))));
-    EXPECT_THAT(res, ContainerEq(src));
-}
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+#include <type_traits>
+
+using testing::ContainerEq;
+using testing::Eq;
+
+TEST(SerializeFSArrayStdArray, ArithmeticValues) {
+    SerializationContext ctx;
+    std::array<int, 4> src{5,9,15,-459};
+    std::array<int, 4> res{};
+
+    ctx.createSerializer().array<sizeof(int)>(src);
+    ctx.createDeserializer().array<sizeof(int)>(res);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * sizeof(int)));
+    EXPECT_THAT(res, ContainerEq(src));
+
+}
+
+TEST(SerializeFSArrayStdArray, CompositeTypes) {
+    SerializationContext ctx;
+    std::array<MyStruct1, 7> src{
+            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
+            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
+    std::array<MyStruct1, 7> res{};
+
+    ctx.createSerializer().array(src);
+    ctx.createDeserializer().array(res);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * MyStruct1::SIZE));
+    EXPECT_THAT(res, ContainerEq(src));
+}
+//
+//
+TEST(SerializeFSArrayStdArray, CustomFunctionThatSerializesAnEmptyByteEveryElement) {
+    SerializationContext ctx;
+    std::array<MyStruct1, 7> src{
+            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
+            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
+    std::array<MyStruct1, 7> res{};
+
+
+    auto ser = ctx.createSerializer();
+    ser.array(src, [](auto &s, auto& v) {
+        char tmp{};
+        s.object(v).value1(tmp);
+    });
+    auto des = ctx.createDeserializer();
+    des.array(res, [](auto &s, auto& v) {
+        char tmp{};
+        s.object(v).value1(tmp);
+    });
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(src.size() * (MyStruct1::SIZE + sizeof(char))));
+    EXPECT_THAT(res, ContainerEq(src));
+}
+
+TEST(SerializeFSArrayCArray, ArithmeticValuesSettingValueSizeExplicitly) {
+    SerializationContext ctx;
+    int src[4]{5,9,15,-459};
+    int res[4]{};
+
+    ctx.createSerializer().array<sizeof(int)>(src);
+    ctx.createDeserializer().array<sizeof(int)>(res);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * sizeof(int)));
+    EXPECT_THAT(res, ContainerEq(src));
+
+}
+
+TEST(SerializeFSArrayCArray, CompositeTypes) {
+    SerializationContext ctx;
+    MyStruct1 src[]{
+            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
+            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
+    MyStruct1 res[7]{};
+
+    ctx.createSerializer().array(src);
+    ctx.createDeserializer().array(res);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * MyStruct1::SIZE));
+    EXPECT_THAT(res, ContainerEq(src));
+}
+//
+//
+TEST(SerializeFSArrayCArray, CustomFunctionThatSerializesAnEmptyByteEveryElement) {
+    SerializationContext ctx;
+    MyStruct1 src[]{
+            MyStruct1{0,1}, MyStruct1{2,3}, MyStruct1{4,5}, MyStruct1{6,7},
+            MyStruct1{8,9}, MyStruct1{11,34}, MyStruct1{5134,1532}};
+    MyStruct1 res[7]{};
+
+
+    auto ser = ctx.createSerializer();
+    ser.array(src, [](auto& s, auto& v) {
+        char tmp{};
+        s.object(v).value1(tmp);
+    });
+    auto des = ctx.createDeserializer();
+    des.array(res, [](auto& s, auto& v) {
+        char tmp{};
+        s.object(v).value1(tmp);
+    });
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(std::extent<decltype(src)>::value * (MyStruct1::SIZE + sizeof(char))));
+    EXPECT_THAT(res, ContainerEq(src));
+}

tests/serialization_objects.cpp

@@ -1,173 +1,176 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-
-#include <bitsery/delta_serializer.h>
-#include <bitsery/delta_deserializer.h>
-
-#include <list>
-
-using testing::Eq;
-using testing::StrEq;
-using testing::ContainerEq;
-
-struct X {
-	X() {};
-	X(int v) :x{ v } {}
-	std::string s{};
-	int x{};
-	bool operator ==(const X& r) const {
-		return r.x == x && r.s == s;
-	}
-};
-
-
-struct Y {
-	int y{};
-	int carr[3];
-	std::array<int, 3> arr;
-	std::vector<X> vx;
-	std::string s;
-};
-struct Z { X x{}; Y y{}; };
-
-
-SERIALIZE(Z)
-{
-	s.object(o.x);
-	s.object(o.y);
-	return s;
-}
-
-SERIALIZE(X)
-{
-	return s.value(o.x)
-		.text(o.s, 1000);
-}
-
-SERIALIZE(Y)
-{
-	auto writeInt = [&s](auto& v) { s.template value<4>(v); };
-	s.text(o.s, 10000);
-	s.template value<4>(o.y);
-	s.array(o.arr, writeInt);
-	s.array(o.carr, writeInt);
-	s.container(o.vx, [&s](auto& v) { s.object(v); }, 10000);
-	return s;
-}
-
-TEST(SerializeObject, GeneralConceptTest) {
-	//std::string buf;
-	SerializationContext ctx;
-	Y y{};
-	y.y = 3423;
-	y.arr[0] = 111;
-	y.arr[1] = 222;
-	y.arr[2] = 333;
-	y.carr[0] = 123;
-	y.carr[1] = 456;
-	y.carr[2] = 789;
-	y.vx.push_back(X(234));
-	y.vx.push_back(X(6245));
-	y.vx.push_back(X(613461));
-	y.s = "labal diena";
-
-	Z z{};
-	z.y = y;
-	z.x = X{ 234 };
-	
-
-	auto ser = ctx.createSerializer();
-	ser.object(y);
-	ser.object(z);
-
-
-	Y yres{};
-	Z zres{};
-
-	auto des = ctx.createDeserializer();
-	des.object(yres);
-	des.object(zres);
-
-	EXPECT_THAT(yres.y, Eq(y.y));
-	EXPECT_THAT(yres.vx, ContainerEq(y.vx));
-	EXPECT_THAT(yres.arr, ContainerEq(y.arr));
-	EXPECT_THAT(yres.carr, ContainerEq(y.carr));
-	EXPECT_THAT(yres.s, StrEq(y.s));
-
-	EXPECT_THAT(zres.y.y, Eq(z.y.y));
-	EXPECT_THAT(zres.y.vx, ContainerEq(z.y.vx));
-	EXPECT_THAT(zres.y.arr, ContainerEq(z.y.arr));
-	EXPECT_THAT(zres.y.carr, ContainerEq(z.y.carr));
-	EXPECT_THAT(zres.y.s, StrEq(z.y.s));
-	EXPECT_THAT(zres.x.s, StrEq(z.x.s));
-	EXPECT_THAT(zres.x.x, Eq(z.x.x));
-
-}
-
-TEST(DeltaSerializer, GeneralConceptTest) {
-	//std::string buf;
-	Y y{};
-	y.y = 3423;
-	y.arr[0] = 111;
-	y.arr[1] = 222;
-	y.arr[2] = 333;
-	y.carr[0] = 123;
-	y.carr[1] = 456;
-	y.carr[2] = 789;
-	y.vx.push_back(X(234));
-	y.vx.push_back(X(6245));
-	y.vx.push_back(X(613461));
-	y.s = "labal diena";
-	y.vx[0].s = "very nice";
-	y.vx[1].s = "very nice string, that is a little bit longer that previous";
-
-	Y yRead = y;
-	Y yNew = y;	
-	yNew.y = 111111;
-	yNew.arr[2] = 0xFFFFFFFF;
-	yNew.carr[1] = 0xFFFFFFFF;
-	yNew.s = "labas dienaABC";
-	yNew.vx[0].s = "very opapa";
-	yNew.vx[1].s = "bla";
-	yNew.vx.push_back(X{ 3 });
-
-	std::vector<uint8_t> buf;
-	bitsery::BufferWriter bw{ buf };
-	bitsery::DeltaSerializer<bitsery::BufferWriter, Y> ser(bw, y, yNew);
-	serialize(ser, yNew);
-	bw.flush();
-
-	bitsery::BufferReader br{ buf };
-	bitsery::DeltaDeserializer<bitsery::BufferReader, Y> des(br, y, yRead);
-	serialize(des, yRead);
-
-	EXPECT_THAT(yRead.y, Eq(yNew.y));
-	EXPECT_THAT(yRead.vx, ContainerEq(yNew.vx));
-	EXPECT_THAT(yRead.arr, ContainerEq(yNew.arr));
-	EXPECT_THAT(yRead.carr, ContainerEq(yNew.carr));
-	EXPECT_THAT(yRead.s, StrEq(yNew.s));
-}
-
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+
+#include <bitsery/delta_serializer.h>
+#include <bitsery/delta_deserializer.h>
+
+#include <list>
+
+
+
+using testing::Eq;
+using testing::StrEq;
+using testing::ContainerEq;
+
+struct X {
+	X() {};
+	X(int v) :x{ v } {}
+	std::string s{};
+	int x{};
+	bool operator ==(const X& r) const {
+		return r.x == x && r.s == s;
+	}
+};
+
+
+struct Y {
+	int y{};
+	int carr[3];
+	std::array<int, 3> arr;
+	std::vector<X> vx;
+	std::string s;
+};
+struct Z { X x{}; Y y{}; };
+
+
+SERIALIZE(Z)
+{
+	s.object(o.x);
+	s.object(o.y);
+	return s;
+}
+
+SERIALIZE(X)
+{
+	return s.template value<sizeof(o.x)>(o.x)
+		.template text<1>(o.s, 1000);
+}
+
+SERIALIZE(Y)
+{
+	auto writeInt = [](auto& s, auto& v) { s.template value<sizeof(v)>(v); };
+	s.template text<1>(o.s, 10000);
+	s.template value<sizeof(o.y)>(o.y);
+	s.array(o.arr, writeInt);
+	s.array(o.carr, writeInt);
+	s.container(o.vx, 10000, [](auto& s, auto& v) { s.object(v); });
+	return s;
+}
+
+
+TEST(SerializeObject, GeneralConceptTest) {
+	//std::string buf;
+	SerializationContext ctx;
+	Y y{};
+	y.y = 3423;
+	y.arr[0] = 111;
+	y.arr[1] = 222;
+	y.arr[2] = 333;
+	y.carr[0] = 123;
+	y.carr[1] = 456;
+	y.carr[2] = 789;
+	y.vx.push_back(X(234));
+	y.vx.push_back(X(6245));
+	y.vx.push_back(X(613461));
+	y.s = "labal diena";
+
+	Z z{};
+	z.y = y;
+	z.x = X{ 234 };
+	
+
+	auto ser = ctx.createSerializer();
+	ser.object(y);
+	ser.object(z);
+
+
+	Y yres{};
+	Z zres{};
+
+	auto des = ctx.createDeserializer();
+	des.object(yres);
+	des.object(zres);
+
+	EXPECT_THAT(yres.y, Eq(y.y));
+	EXPECT_THAT(yres.vx, ContainerEq(y.vx));
+	EXPECT_THAT(yres.arr, ContainerEq(y.arr));
+	EXPECT_THAT(yres.carr, ContainerEq(y.carr));
+	EXPECT_THAT(yres.s, StrEq(y.s));
+
+	EXPECT_THAT(zres.y.y, Eq(z.y.y));
+	EXPECT_THAT(zres.y.vx, ContainerEq(z.y.vx));
+	EXPECT_THAT(zres.y.arr, ContainerEq(z.y.arr));
+	EXPECT_THAT(zres.y.carr, ContainerEq(z.y.carr));
+	EXPECT_THAT(zres.y.s, StrEq(z.y.s));
+	EXPECT_THAT(zres.x.s, StrEq(z.x.s));
+	EXPECT_THAT(zres.x.x, Eq(z.x.x));
+
+}
+
+TEST(DeltaSerializer, GeneralConceptTest) {
+	//std::string buf;
+	Y y{};
+	y.y = 3423;
+	y.arr[0] = 111;
+	y.arr[1] = 222;
+	y.arr[2] = 333;
+	y.carr[0] = 123;
+	y.carr[1] = 456;
+	y.carr[2] = 789;
+	y.vx.push_back(X(234));
+	y.vx.push_back(X(6245));
+	y.vx.push_back(X(613461));
+	y.s = "labal diena";
+	y.vx[0].s = "very nice";
+	y.vx[1].s = "very nice string, that is a little bit longer that previous";
+
+	Y yRead = y;
+	Y yNew = y;	
+	yNew.y = 111111;
+	yNew.arr[2] = 0xFFFFFFFF;
+	yNew.carr[1] = 0xFFFFFFFF;
+	yNew.s = "labas dienaABC";
+	yNew.vx[0].s = "very opapa";
+	yNew.vx[1].s = "bla";
+	yNew.vx.push_back(X{ 3 });
+
+	std::vector<bitsery::DefaultConfig::BufferValueType> buf;
+	bitsery::BufferWriter bw{ buf };
+	bitsery::DeltaSerializer<bitsery::BufferWriter, Y> ser(bw, y, yNew);
+	serialize(ser, yNew);
+	bw.flush();
+
+	bitsery::BufferReader br{ buf };
+	bitsery::DeltaDeserializer<bitsery::BufferReader, Y> des(br, y, yRead);
+	serialize(des, yRead);
+
+	EXPECT_THAT(yRead.y, Eq(yNew.y));
+	EXPECT_THAT(yRead.vx, ContainerEq(yNew.vx));
+	EXPECT_THAT(yRead.arr, ContainerEq(yNew.arr));
+	EXPECT_THAT(yRead.carr, ContainerEq(yNew.carr));
+	EXPECT_THAT(yRead.s, StrEq(yNew.s));
+}
+

tests/serialization_range.cpp

@@ -29,17 +29,17 @@ using bitsery::BitsConstraint;
 
 TEST(SerializeRange, RequiredBitsIsConstexpr) {
     constexpr RangeSpec<int> r1{0, 31};
-    static_assert(r1.bitsRequired == 5);
+    static_assert(r1.bitsRequired == 5, "r1.bitsRequired == 5");
 
     constexpr RangeSpec<MyEnumClass> r2{MyEnumClass::E1, MyEnumClass::E4};
-    static_assert(r2.bitsRequired == 2);
+    static_assert(r2.bitsRequired == 2, "r2.bitsRequired == 2");
 
     constexpr RangeSpec<double> r3{-1.0,1.0, BitsConstraint{5u}};
     //EXPECT_THAT(r1.bitsRequired, Eq(5));
-    static_assert(r3.bitsRequired == 5);
+    static_assert(r3.bitsRequired == 5, "r3.bitsRequired == 5");
 
     constexpr RangeSpec<float> r4{-1.0f,1.0f, 0.01f};
-    static_assert(r4.bitsRequired == 8);
+    static_assert(r4.bitsRequired == 8, "r4.bitsRequired == 8");
 
 }
 
@@ -133,7 +133,7 @@ TEST(SerializeRange, FloatUsingBitsSizeConstraint1) {
     ctx.createDeserializer().range(res1, r1);
 
     EXPECT_THAT(ctx.getBufferSize(), Eq(1));
-    EXPECT_THAT(res1, ::testing::FloatNear(t1, (max - min) / (static_cast<bitsery::SAME_SIZE_UNSIGNED<float>>(1) << bits)));
+    EXPECT_THAT(res1, ::testing::FloatNear(t1, (max - min) / (static_cast<bitsery::details::SAME_SIZE_UNSIGNED<float>>(1) << bits)));
 }
 
 TEST(SerializeRange, DoubleUsingBitsSizeConstraint2) {
@@ -150,5 +150,5 @@ TEST(SerializeRange, DoubleUsingBitsSizeConstraint2) {
     ctx.createDeserializer().range(res1, r1);
 
     EXPECT_THAT(ctx.getBufferSize(), Eq(7));
-    EXPECT_THAT(res1, ::testing::DoubleNear(t1, (max - min) / (static_cast<bitsery::SAME_SIZE_UNSIGNED<double>>(1) << bits)));
+    EXPECT_THAT(res1, ::testing::DoubleNear(t1, (max - min) / (static_cast<bitsery::details::SAME_SIZE_UNSIGNED<double>>(1) << bits)));
 }

tests/serialization_size.cpp

@@ -28,9 +28,9 @@ using testing::Eq;
 
 bool SerializeDeserializeContainerSize(SerializationContext& ctx, const size_t size) {
     std::vector<char> t1(size);
-    ctx.createSerializer().container(t1, [](auto ){}, size+1);
+    ctx.createSerializer().container(t1, size+1, [](auto , auto ){});
     t1.clear();
-    ctx.createDeserializer().container(t1, [](auto ){}, size+1);
+    ctx.createDeserializer().container(t1, size+1, [](auto , auto ){});
     return t1.size() == size;
 }
 

tests/serialization_substitution.cpp

@@ -1,162 +1,135 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-using namespace testing;
-
-TEST(SerializeSubstitution, WhenSubstitutedThenOnlyWriteIndexUsingMinRequiredBits) {
-    int v = 4849;
-    int res;
-    constexpr size_t N = 3;
-    std::array<int,N> subsitution{485,4849,89};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution(v, subsitution);
-    ctx.createDeserializer().substitution(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
-
-    SerializationContext ctx1;
-    ctx1.createSerializer().substitution(v, subsitution);
-    auto des = ctx1.createDeserializer();
-    des.range(res, {0, N + 1});
-    EXPECT_THAT(res, Eq(2));
-}
-
-TEST(SerializeSubstitution, WhenNoSubstitutionThenWriteZeroBitsAndValueOrObject) {
-    int v = 8945;
-    int res;
-    std::array<int,3> subsitution{485,4849,89};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution(v, subsitution);
-    ctx.createDeserializer().substitution(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(sizeof(int)+1));
-}
-
-TEST(SerializeSubstitution, CustomTypeSubstituted) {
-    MyStruct1 v = {12,10};
-    MyStruct1 res;
-    constexpr size_t N = 4;
-    std::array<MyStruct1, N> subsitution = {
-            MyStruct1{12,10}, MyStruct1{485, 454},
-            MyStruct1{4849,89}, MyStruct1{0,1}};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution(v, subsitution);
-    ctx.createDeserializer().substitution(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
-}
-
-TEST(SerializeSubstitution, CustomTypeNotSubstituted) {
-    MyStruct1 v = {8945,4456};
-    MyStruct1 res;
-    constexpr size_t N = 4;
-    std::array<MyStruct1, N> subsitution = {
-            MyStruct1{12,10}, MyStruct1{485, 454},
-            MyStruct1{4849,89}, MyStruct1{0,1}};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution(v, subsitution);
-    ctx.createDeserializer().substitution(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(MyStruct1::SIZE + 1));
-}
-
-TEST(SerializeSubstitution, ArithmeticTypeWithExplicitSizeNotSubstituted) {
-    MyEnumClass v = MyEnumClass::E5;
-    MyEnumClass res;
-    constexpr size_t N = 3;
-    std::array<MyEnumClass,N> subsitution{MyEnumClass::E1,MyEnumClass::E2,MyEnumClass::E3};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution<sizeof(MyEnumClass)>(v, subsitution);
-    ctx.createDeserializer().substitution<sizeof(MyEnumClass)>(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(sizeof(MyEnumClass) + 1));
-}
-
-TEST(SerializeSubstitution, ArithmeticTypeWithExplicitSizeSubstituted) {
-    MyEnumClass v = MyEnumClass::E1;
-    MyEnumClass res;
-    constexpr size_t N = 3;
-    std::array<MyEnumClass,N> subsitution{MyEnumClass::E1,MyEnumClass::E2,MyEnumClass::E3};
-    SerializationContext ctx;
-    ctx.createSerializer().substitution<sizeof(MyEnumClass)>(v, subsitution);
-    ctx.createDeserializer().substitution<sizeof(MyEnumClass)>(res, subsitution);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
-}
-
-
-TEST(SerializeSubstitution, CustomFunctionNotSubstituted) {
-    MyStruct1 v = {8945,4456};
-    MyStruct1 res;
-    constexpr size_t N = 4;
-    std::array<MyStruct1, N> subsitution = {
-            MyStruct1{12,10}, MyStruct1{485, 454},
-            MyStruct1{4849,89}, MyStruct1{0,1}};
-
-    auto rangeForValue = bitsery::RangeSpec<int>(0, 10000);
-    auto rangeForIndex = bitsery::RangeSpec<size_t>{0, N+1};
-
-    SerializationContext ctx;
-    auto ser = ctx.createSerializer();
-
-    //lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
-    auto serLambda = [&ser, rangeForValue](const MyStruct1& v) {
-        ser.range(v.i1, rangeForValue);
-        ser.range(v.i2, rangeForValue);
-    };
-    ser.substitution(v, subsitution, serLambda);
-
-    auto des = ctx.createDeserializer();
-    auto desLambda = [&des, rangeForValue](MyStruct1& v) {
-        des.range(v.i1, rangeForValue);
-        des.range(v.i2, rangeForValue);
-    };
-    des.substitution(res, subsitution, desLambda);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq((rangeForIndex.bitsRequired + rangeForValue.bitsRequired * 2 - 1) / 8 + 1 ));
-}
-
-TEST(SerializeSubstitution, WhenSubstitutedThenCustomFunctionNotInvoked) {
-    MyStruct1 v = {4849,89};
-    MyStruct1 res;
-    constexpr size_t N = 4;
-    std::array<MyStruct1, N> subsitution = {
-            MyStruct1{12,10}, MyStruct1{485, 454},
-            MyStruct1{4849,89}, MyStruct1{0,1}};
-
-    SerializationContext ctx;
-    ctx.createSerializer().substitution(v, subsitution, [](const MyStruct1& ) {});
-    ctx.createDeserializer().substitution(res, subsitution, [](MyStruct1& ) {});
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
-}
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+using namespace testing;
+
+TEST(SerializeSubstitution, WhenSubstitutedThenOnlyWriteIndexUsingMinRequiredBits) {
+    int32_t v = 4849;
+    int32_t res;
+    constexpr size_t N = 3;
+    std::array<int32_t,N> subsitution{485,4849,89};
+    SerializationContext ctx;
+    ctx.createSerializer().substitution<4>(v, subsitution);
+    ctx.createDeserializer().substitution<4>(res, subsitution);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
+
+    SerializationContext ctx1;
+    ctx1.createSerializer().substitution<4>(v, subsitution);
+    auto des = ctx1.createDeserializer();
+    des.range(res, {0, N + 1});
+    EXPECT_THAT(res, Eq(2));
+}
+
+TEST(SerializeSubstitution, WhenNoSubstitutionThenWriteZeroBitsAndValueOrObject) {
+    int16_t v = 8945;
+    int16_t res;
+    std::array<int16_t,3> subsitution{485,4849,89};
+    SerializationContext ctx;
+    ctx.createSerializer().substitution<2>(v, subsitution);
+    ctx.createDeserializer().substitution<2>(res, subsitution);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(sizeof(int16_t)+1));
+}
+
+TEST(SerializeSubstitution, CustomTypeSubstituted) {
+    MyStruct1 v = {12,10};
+    MyStruct1 res;
+    constexpr size_t N = 4;
+    std::array<MyStruct1, N> subsitution = {
+            MyStruct1{12,10}, MyStruct1{485, 454},
+            MyStruct1{4849,89}, MyStruct1{0,1}};
+    SerializationContext ctx;
+    ctx.createSerializer().substitution(v, subsitution);
+    ctx.createDeserializer().substitution(res, subsitution);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
+}
+
+TEST(SerializeSubstitution, CustomTypeNotSubstituted) {
+    MyStruct1 v = {8945,4456};
+    MyStruct1 res;
+    constexpr size_t N = 4;
+    std::array<MyStruct1, N> subsitution = {
+            MyStruct1{12,10}, MyStruct1{485, 454},
+            MyStruct1{4849,89}, MyStruct1{0,1}};
+    SerializationContext ctx;
+    ctx.createSerializer().substitution(v, subsitution);
+    ctx.createDeserializer().substitution(res, subsitution);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(MyStruct1::SIZE + 1));
+}
+
+TEST(SerializeSubstitution, CustomFunctionNotSubstituted) {
+    MyStruct1 v = {8945,4456};
+    MyStruct1 res;
+    constexpr size_t N = 4;
+    std::array<MyStruct1, N> subsitution = {
+            MyStruct1{12,10}, MyStruct1{485, 454},
+            MyStruct1{4849,89}, MyStruct1{0,1}};
+
+    auto rangeForValue = bitsery::RangeSpec<int>(0, 10000);
+    auto rangeForIndex = bitsery::RangeSpec<size_t>{0, N+1};
+
+    SerializationContext ctx;
+    auto ser = ctx.createSerializer();
+
+    //lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
+    auto serLambda = [rangeForValue](auto& s, const MyStruct1& v) {
+        s.range(v.i1, rangeForValue);
+        s.range(v.i2, rangeForValue);
+    };
+    ser.substitution(v, subsitution, serLambda);
+
+    auto des = ctx.createDeserializer();
+    auto desLambda = [rangeForValue](auto& s, MyStruct1& v) {
+        s.range(v.i1, rangeForValue);
+        s.range(v.i2, rangeForValue);
+    };
+    des.substitution(res, subsitution, desLambda);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq((rangeForIndex.bitsRequired + rangeForValue.bitsRequired * 2 - 1) / 8 + 1 ));
+}
+
+TEST(SerializeSubstitution, WhenSubstitutedThenCustomFunctionNotInvoked) {
+    MyStruct1 v = {4849,89};
+    MyStruct1 res;
+    constexpr size_t N = 4;
+    std::array<MyStruct1, N> subsitution = {
+            MyStruct1{12,10}, MyStruct1{485, 454},
+            MyStruct1{4849,89}, MyStruct1{0,1}};
+
+    SerializationContext ctx;
+    ctx.createSerializer().substitution(v, subsitution, [](bitsery::Serializer<bitsery::BufferWriter>& ,const MyStruct1& ) {});
+    ctx.createDeserializer().substitution(res, subsitution, [](bitsery::Deserializer<bitsery::BufferReader>&, MyStruct1& ) {});
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(ctx.getBufferSize(), Eq(1));
+}

tests/serialization_test_utils.h

@@ -1,103 +1,109 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#ifndef BITSERY_SERIALIZERTESTS_H
-#define BITSERY_SERIALIZERTESTS_H
-
-#include <bitsery/bitsery.h>
-#include <memory>
-
-struct MyStruct1 {
-    MyStruct1(int v1, int v2):i1{v1}, i2{v2} {}
-    MyStruct1():MyStruct1{0,0} {}
-    int i1;
-    int i2;
-    bool operator == (const MyStruct1& rhs) const {
-        return i1 == rhs.i1 && i2 == rhs.i2;
-    }
-    static constexpr size_t SIZE = sizeof(MyStruct1::i1) + sizeof(MyStruct1::i2);
-};
-
-SERIALIZE(MyStruct1) {
-    return s.
-            value(o.i1).
-            value(o.i2);
-}
-
-enum class MyEnumClass {
-    E1, E2, E3, E4, E5, E6
-};
-
-struct MyStruct2 {
-    enum MyEnum {
-        V1, V2, V3, V4, V5, V6
-    };
-
-    MyStruct2(MyEnum e, MyStruct1 s):e1{e}, s1{s} {}
-    MyStruct2():MyStruct2{V1,{0,0}} {}
-
-    MyEnum e1;
-    MyStruct1 s1;
-    bool operator == (const MyStruct2& rhs) const {
-        return e1 == rhs.e1 && s1 == rhs.s1;
-    }
-    static constexpr size_t SIZE = MyStruct1::SIZE + sizeof(MyStruct2::e1);
-};
-
-SERIALIZE(MyStruct2) {
-    return s.
-            value(o.e1).
-            object(o.s1);
-}
-
-class SerializationContext {
-    std::vector<uint8_t> buf{};
-    std::unique_ptr<bitsery::BufferWriter> bw;
-    std::unique_ptr<bitsery::BufferReader> br;
-public:
-    bitsery::Serializer<bitsery::BufferWriter> createSerializer() {
-        bw = std::make_unique<bitsery::BufferWriter>(buf);
-        return {*bw};
-    };
-
-    size_t getBufferSize() const {
-        return buf.size();
-    }
-    //since all containers .size() method returns size_t, it cannot be dirrectly serialized, because size_t is platform dependant
-    //this function returns number of bytes writen to buffer, when reading/writing size of container
-    static size_t containerSizeSerializedBytesCount(size_t elemsCount) {
-        if (elemsCount < 0x80u)
-            return 1;
-        if (elemsCount < 0x4000u)
-            return 2;
-        return 4;
-    }
-
-    bitsery::Deserializer<bitsery::BufferReader> createDeserializer() {
-        bw->flush();
-        br = std::make_unique<bitsery::BufferReader>(buf);
-        return {*br};
-    };
-};
-
-#endif //BITSERY_SERIALIZERTESTS_H
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#ifndef BITSERY_SERIALIZERTESTS_H
+#define BITSERY_SERIALIZERTESTS_H
+
+#include <bitsery/bitsery.h>
+#include <memory>
+
+
+/*
+ * define some types for testing
+ */
+
+struct MyStruct1 {
+    MyStruct1(int v1, int v2):i1{v1}, i2{v2} {}
+    MyStruct1():MyStruct1{0,0} {}
+    int i1;
+    int i2;
+    bool operator == (const MyStruct1& rhs) const {
+        return i1 == rhs.i1 && i2 == rhs.i2;
+    }
+    static constexpr size_t SIZE = sizeof(MyStruct1::i1) + sizeof(MyStruct1::i2);
+};
+
+SERIALIZE(MyStruct1) {
+    return s.
+            template value<sizeof(o.i1)>(o.i1).
+            template value<sizeof(o.i2)>(o.i2);
+}
+
+enum class MyEnumClass {
+    E1, E2, E3, E4, E5, E6
+};
+
+struct MyStruct2 {
+    enum MyEnum {
+        V1, V2, V3, V4, V5, V6
+    };
+
+    MyStruct2(MyEnum e, MyStruct1 s):e1{e}, s1{s} {}
+    MyStruct2():MyStruct2{V1,{0,0}} {}
+
+    MyEnum e1;
+    MyStruct1 s1;
+    bool operator == (const MyStruct2& rhs) const {
+        return e1 == rhs.e1 && s1 == rhs.s1;
+    }
+    static constexpr size_t SIZE = MyStruct1::SIZE + sizeof(MyStruct2::e1);
+};
+
+SERIALIZE(MyStruct2) {
+    return s.
+            template value<sizeof(o.e1)>(o.e1).
+            object(o.s1);
+}
+
+
+class SerializationContext {
+    std::vector<bitsery::DefaultConfig::BufferValueType> buf{};
+    std::unique_ptr<bitsery::BufferWriter> bw;
+    std::unique_ptr<bitsery::BufferReader> br;
+public:
+    bitsery::Serializer<bitsery::BufferWriter> createSerializer() {
+        bw = std::make_unique<bitsery::BufferWriter>(buf);
+        return {*bw};
+    };
+
+    size_t getBufferSize() const {
+        return buf.size();
+    }
+    //since all containers .size() method returns size_t, it cannot be directly serialized, because size_t is platform dependant
+    //this function returns number of bytes writen to buffer, when reading/writing size of container
+    static size_t containerSizeSerializedBytesCount(size_t elemsCount) {
+        if (elemsCount < 0x80u)
+            return 1;
+        if (elemsCount < 0x4000u)
+            return 2;
+        return 4;
+    }
+
+    bitsery::Deserializer<bitsery::BufferReader> createDeserializer() {
+        bw->flush();
+        br = std::make_unique<bitsery::BufferReader>(buf);
+        return {*br};
+    };
+};
+
+#endif //BITSERY_SERIALIZERTESTS_H

tests/serialization_text.cpp

@@ -1,138 +1,124 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-using namespace testing;
-
-TEST(SerializeText, BasicString) {
-    SerializationContext ctx;
-    std::string t1 = "some random text";
-    std::string res;
-
-    ctx.createSerializer().text(t1, 1000);
-    ctx.createDeserializer().text(res, 1000);
-
-    EXPECT_THAT(res, StrEq(t1));
-    EXPECT_THAT(res, ContainerEq(t1));
-
-}
-
-TEST(SerializeText, WhenSizeOfTypeNotEqualsOneThenSetSizeExplicitly) {
-    SerializationContext ctx;
-    constexpr auto VSIZE = sizeof(char32_t);
-    std::basic_string<char32_t> t1 = U"some random text";
-    std::basic_string<char32_t> res;
-    static_assert(VSIZE > 1, "on this system, all character types has sizeof == 1, cannot run this tests");
-
-    ctx.createSerializer().text<VSIZE>(t1, 1000);
-    ctx.createDeserializer().text<VSIZE>(res, 1000);
-
-    EXPECT_THAT(res, ContainerEq(t1));
-}
-
-TEST(SerializeText, BasicStringUseSizeMethodNotNullterminatedLength) {
-    SerializationContext ctx;
-    std::wstring t1(L"some random text\0xxxxxx", 20);
-    std::wstring wres;
-    constexpr auto VSIZE = sizeof(std::wstring::value_type);
-
-    ctx.createSerializer().text<VSIZE>(t1, 1000);
-    ctx.createDeserializer().text<VSIZE>(wres, 1000);
-
-    EXPECT_THAT(wres, StrEq(t1));
-    EXPECT_THAT(wres.size(), Eq(t1.size()));
-    EXPECT_THAT(wres.size(), Gt(std::char_traits<std::wstring::value_type>::length(t1.data())));
-
-    SerializationContext ctx2;
-    std::string t2("\0no one cares what is there", 10);
-    std::string res;
-    ctx2.createSerializer().text(t2, 1000);
-    ctx2.createDeserializer().text(res, 1000);
-
-    EXPECT_THAT(res, StrEq(t2));
-    EXPECT_THAT(res.size(), Eq(t2.size()));
-
-    SerializationContext ctx3;
-    std::string t3("never ending buffer that doesnt fit in this string", 10);
-    ctx3.createSerializer().text(t3, 1000);
-    ctx3.createDeserializer().text(res, 1000);
-    EXPECT_THAT(res, StrEq(t3));
-    EXPECT_THAT(res.size(), Eq(10));
-}
-
-const int CARR_LENGTH = 10;
-
-TEST(SerializeText, CArraySerializesTextLength) {
-    SerializationContext ctx;
-    char t1[CARR_LENGTH]{"some text"};
-    char r1[CARR_LENGTH]{};
-
-    ctx.createSerializer().text(t1);
-    ctx.createDeserializer().text(r1);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(CARR_LENGTH) +
-                                                std::char_traits<char>::length(t1)));
-
-    EXPECT_THAT(r1, StrEq(t1));
-    EXPECT_THAT(r1, ContainerEq(t1));
-
-    //zero length string
-    t1[0] = 0;
-    SerializationContext ctx2;
-    ctx2.createSerializer().text(t1);
-    ctx2.createDeserializer().text(r1);
-
-    EXPECT_THAT(ctx2.getBufferSize(), Eq(ctx2.containerSizeSerializedBytesCount(CARR_LENGTH)));
-    EXPECT_THAT(r1, StrEq(t1));
-    EXPECT_THAT(r1, ContainerEq(t1));
-}
-
-TEST(SerializeText, WhenCArrayWithLargerTypeThenSetSizeExplicitly) {
-    SerializationContext ctx;
-    char32_t t1[10]{U"some text"};
-    char32_t r1[10]{};
-    constexpr auto SIZE = sizeof(char32_t);
-    ctx.createSerializer().text<SIZE>(t1);
-    ctx.createDeserializer().text<SIZE>(r1);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(CARR_LENGTH) +
-                                                std::char_traits<char32_t>::length(t1) * SIZE));
-    EXPECT_THAT(r1, ContainerEq(t1));
-}
-
-
-TEST(SerializeText, WhenCArrayNotNullterminatedThenMakeItNullterminated) {
-    SerializationContext ctx;
-    char t1[CARR_LENGTH]{"some text"};
-    //make last character not nullterminated
-    t1[CARR_LENGTH-1] = 'x';
-    char r1[CARR_LENGTH]{};
-
-    ctx.createSerializer().text(t1);
-    ctx.createDeserializer().text(r1);
-
-    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(CARR_LENGTH) +
-                                                CARR_LENGTH - 1));
-    EXPECT_THAT(r1[CARR_LENGTH-1], Eq(0));
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+using namespace testing;
+
+TEST(SerializeText, BasicString) {
+    SerializationContext ctx;
+    std::string t1 = "some random text";
+    std::string res;
+
+    ctx.createSerializer().text<sizeof(std::string::value_type)>(t1, 1000);
+    ctx.createDeserializer().text<sizeof(std::string::value_type)>(res, 1000);
+
+    EXPECT_THAT(res, StrEq(t1));
+    EXPECT_THAT(res, ContainerEq(t1));
+
+}
+
+TEST(SerializeText, WhenSizeOfTypeNotEqualsOneThenSetSizeExplicitly) {
+    SerializationContext ctx;
+    constexpr auto VSIZE = sizeof(char32_t);
+    std::basic_string<char32_t> t1 = U"some random text";
+    std::basic_string<char32_t> res;
+    static_assert(VSIZE > 1, "on this system, all character types has sizeof == 1, cannot run this tests");
+
+    ctx.createSerializer().text<VSIZE>(t1, 1000);
+    ctx.createDeserializer().text<VSIZE>(res, 1000);
+
+    EXPECT_THAT(res, ContainerEq(t1));
+}
+
+TEST(SerializeText, BasicStringUseSizeMethodNotNullterminatedLength) {
+    SerializationContext ctx;
+    std::wstring t1(L"some random text\0xxxxxx", 20);
+    std::wstring wres;
+    constexpr auto VSIZE = sizeof(std::wstring::value_type);
+
+    ctx.createSerializer().text<VSIZE>(t1, 1000);
+    ctx.createDeserializer().text<VSIZE>(wres, 1000);
+
+    EXPECT_THAT(wres, StrEq(t1));
+    EXPECT_THAT(wres.size(), Eq(t1.size()));
+    EXPECT_THAT(wres.size(), Gt(std::char_traits<std::wstring::value_type>::length(t1.data())));
+
+    SerializationContext ctx2;
+    std::string t2("\0no one cares what is there", 10);
+    std::string res;
+    ctx2.createSerializer().text<sizeof(std::string::value_type)>(t2, 1000);
+    ctx2.createDeserializer().text<sizeof(std::string::value_type)>(res, 1000);
+
+    EXPECT_THAT(res, StrEq(t2));
+    EXPECT_THAT(res.size(), Eq(t2.size()));
+
+    SerializationContext ctx3;
+    std::string t3("never ending buffer that doesnt fit in this string", 10);
+    ctx3.createSerializer().text<sizeof(std::string::value_type)>(t3, 1000);
+    ctx3.createDeserializer().text<sizeof(std::string::value_type)>(res, 1000);
+    EXPECT_THAT(res, StrEq(t3));
+    EXPECT_THAT(res.size(), Eq(10));
+}
+
+constexpr int CARR_LENGTH = 10;
+
+TEST(SerializeText, CArraySerializesTextLength) {
+    SerializationContext ctx;
+    char t1[CARR_LENGTH]{"some text"};
+    char r1[CARR_LENGTH]{};
+
+    ctx.createSerializer().text<1>(t1);
+    ctx.createDeserializer().text<1>(r1);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(CARR_LENGTH) +
+                                                std::char_traits<char>::length(t1)));
+
+    EXPECT_THAT(r1, StrEq(t1));
+    EXPECT_THAT(r1, ContainerEq(t1));
+
+    //zero length string
+    t1[0] = 0;
+    SerializationContext ctx2;
+    ctx2.createSerializer().text<1>(t1);
+    ctx2.createDeserializer().text<1>(r1);
+
+    EXPECT_THAT(ctx2.getBufferSize(), Eq(ctx2.containerSizeSerializedBytesCount(CARR_LENGTH)));
+    EXPECT_THAT(r1, StrEq(t1));
+    EXPECT_THAT(r1, ContainerEq(t1));
+}
+
+TEST(SerializeText, WhenCArrayNotNullterminatedThenMakeItNullterminated) {
+    SerializationContext ctx;
+    char16_t t1[CARR_LENGTH]{u"some text"};
+    //make last character not nullterminated
+    t1[CARR_LENGTH-1] = 'x';
+    char16_t r1[CARR_LENGTH]{};
+
+    ctx.createSerializer().text<2>(t1);
+    ctx.createDeserializer().text<2>(r1);
+
+    EXPECT_THAT(ctx.getBufferSize(), Eq(ctx.containerSizeSerializedBytesCount(CARR_LENGTH) +
+                                                (CARR_LENGTH - 1) * 2));
+    EXPECT_THAT(r1[CARR_LENGTH-1], Eq(0));
 }

tests/serialization_values.cpp

@@ -1,73 +1,112 @@
-//MIT License
-//
-//Copyright (c) 2017 Mindaugas Vinkelis
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//The above copyright notice and this permission notice shall be included in all
-//copies or substantial portions of the Software.
-//
-//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-//SOFTWARE.
-
-#include <gmock/gmock.h>
-#include "serialization_test_utils.h"
-
-using testing::Eq;
-
-template <typename T>
-bool SerializeDeserializeValue(const T& v) {
-    T res{};
-    SerializationContext ctx;
-    ctx.createSerializer().value(v);
-    ctx.createDeserializer().value(res);
-    return v == res;
-}
-
-TEST(SerializeValues, IntegerTypes) {
-    EXPECT_THAT(SerializeDeserializeValue(-449874), Eq(true));
-    EXPECT_THAT(SerializeDeserializeValue(34u), Eq(true));
-}
-
-TEST(SerializeValues, EnumTypes) {
-    enum E1{
-        A1,B1,C1,D1
-    };
-    EXPECT_THAT(SerializeDeserializeValue(E1::C1), Eq(true));
-    enum class E2 {
-        A2,B2,C2,D2
-    };
-    EXPECT_THAT(SerializeDeserializeValue(E2::B2), Eq(true));
-    enum class E3:short {
-        A3, B3, C3=4568, D3
-    };
-    EXPECT_THAT(SerializeDeserializeValue(E3::C3), Eq(true));
-}
-
-TEST(SerializeValues, FloatingPointTypes) {
-    EXPECT_THAT(SerializeDeserializeValue(-484.465), Eq(true));
-    EXPECT_THAT(SerializeDeserializeValue(0.00000015f), Eq(true));
-}
-
-TEST(SerializeValues, ExplicitTypeSize) {
-    int v{23472};
-    int res;
-    constexpr size_t TSIZE = sizeof(v);
-
-    SerializationContext ctx;
-    ctx.createSerializer().value<TSIZE>(v);
-    ctx.createDeserializer().value<TSIZE>(res);
-
-    EXPECT_THAT(res, Eq(v));
-    EXPECT_THAT(TSIZE, Eq(ctx.getBufferSize()));
-}
+//MIT License
+//
+//Copyright (c) 2017 Mindaugas Vinkelis
+//
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+#include <gmock/gmock.h>
+#include "serialization_test_utils.h"
+
+using testing::Eq;
+
+template <typename T>
+bool SerializeDeserializeValue(const T& v) {
+    T res{};
+    SerializationContext ctx;
+    ctx.createSerializer().value<sizeof(T)>(v);
+    ctx.createDeserializer().value<sizeof(T)>(res);
+    return v == res;
+}
+
+TEST(SerializeValues, IntegerTypes) {
+    EXPECT_THAT(SerializeDeserializeValue(-449874), Eq(true));
+    EXPECT_THAT(SerializeDeserializeValue(34u), Eq(true));
+}
+
+TEST(SerializeValues, EnumTypes) {
+    enum E1{
+        A1,B1,C1,D1
+    };
+    EXPECT_THAT(SerializeDeserializeValue(E1::C1), Eq(true));
+    enum class E2 {
+        A2,B2,C2,D2
+    };
+    EXPECT_THAT(SerializeDeserializeValue(E2::B2), Eq(true));
+    enum class E3:short {
+        A3, B3, C3=4568, D3
+    };
+    EXPECT_THAT(SerializeDeserializeValue(E3::C3), Eq(true));
+}
+
+TEST(SerializeValues, FloatingPointTypes) {
+    EXPECT_THAT(SerializeDeserializeValue(-484.465), Eq(true));
+    EXPECT_THAT(SerializeDeserializeValue(0.00000015f), Eq(true));
+}
+
+TEST(SerializeValues, ValueSizeOverload1Byte) {
+    int8_t v{54};
+    int8_t res;
+    constexpr size_t TSIZE = sizeof(v);
+
+    SerializationContext ctx;
+    ctx.createSerializer().value1(v);
+    ctx.createDeserializer().value1(res);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(TSIZE, Eq(ctx.getBufferSize()));
+}
+
+TEST(SerializeValues, ValueSizeOverload2Byte) {
+    int16_t v{54};
+    int16_t res;
+    constexpr size_t TSIZE = sizeof(v);
+
+    SerializationContext ctx;
+    ctx.createSerializer().value2(v);
+    ctx.createDeserializer().value2(res);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(TSIZE, Eq(ctx.getBufferSize()));
+}
+
+TEST(SerializeValues, ValueSizeOverload4Byte) {
+    float v{54.498f};
+    float res;
+    constexpr size_t TSIZE = sizeof(v);
+
+    SerializationContext ctx;
+    ctx.createSerializer().value4(v);
+    ctx.createDeserializer().value4(res);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(TSIZE, Eq(ctx.getBufferSize()));
+}
+
+TEST(SerializeValues, ValueSizeOverload8Byte) {
+    int64_t v{54};
+    int64_t res;
+    constexpr size_t TSIZE = sizeof(v);
+
+    SerializationContext ctx;
+    ctx.createSerializer().value8(v);
+    ctx.createDeserializer().value8(res);
+
+    EXPECT_THAT(res, Eq(v));
+    EXPECT_THAT(TSIZE, Eq(ctx.getBufferSize()));
+}