bugfix in enableBitPacking

Added interface BasicSerializer &operator()(T &&head, TArgs &&... tail) and BasicDeserializer &operator()(T &&head, TArgs &&... tail), which are cereal like intefaces so such format of serialization functions were possible:

template<class Archive>
void serialize(Archive & ar, DataType& d){
    ar(d.data1, d.data2....);
}

.travis.yml

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

CHANGELOG.md

@@ -1,3 +1,11 @@
+# [4.6.1](https://github.com/fraillt/bitsery/compare/v4.6.0...v4.6.1) (2019-06-27)
+
+### Features
+* flexible syntax now also supports `cereal` like serialization interface (thanks to [Luli2020](https://github.com/Luli2020))
+
+### Bug fixes
+* when using `enableBitPacking`, internal context (i.e. context<T>()) in serializer/deserializer was not copied to/from new bitpacking enabled instance.
+
 # [4.6.0](https://github.com/fraillt/bitsery/compare/v4.5.1...v4.6.0) (2019-03-12)
 
 ### Features

CMakeLists.txt

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

doc/README.md

@@ -15,7 +15,9 @@ Library design:
 
 
 Core Serializer/Deserializer functions (alphabetical order):
+* `operator()` (4.6.1) (when flexible syntax is enabled)
 * `align` (1.0.0)
+* `archive` (4.0.0) (when flexible syntax is enabled)
 * `boolValue` (4.0.0)
 * `container` (1.0.0)
 * `ext` (2.0.0)

examples/flexible_syntax.cpp

@@ -19,11 +19,12 @@ struct MyStruct {
     void serialize(S& s) {
         //now we can use flexible syntax with
         s.archive(i, e, fs);
+        // flexible syntax also supports `cereal` like serialization interface by calling operator()
+        // s(i, e, fs);
     }
 
 };
 
-
 using namespace bitsery;
 
 //some helper types

include/bitsery/adapter_reader.h

@@ -258,6 +258,20 @@ namespace bitsery {
         }
 
     };
+
+    namespace details {
+        // used in "making friends" with non-wrapped deserializer type
+        template <typename TReader>
+        struct GetNonWrappedAdapterReader {
+            using Reader = TReader;
+        };
+
+        template <typename TWrapped>
+        struct GetNonWrappedAdapterReader<AdapterReaderBitPackingWrapper<TWrapped>> {
+            using Reader = TWrapped;
+        };
+    }
+
 }
 
 #endif //BITSERY_ADAPTER_READER_H

include/bitsery/adapter_writer.h

@@ -330,6 +330,19 @@ namespace bitsery {
         TWriter& _writer;
 
     };
+
+    namespace details {
+        // used in "making friends" with non-wrapped serializer type
+        template <typename TWriter>
+        struct GetNonWrappedAdapterWriter {
+            using Writer = TWriter;
+        };
+
+        template <typename TWrapped>
+        struct GetNonWrappedAdapterWriter<AdapterWriterBitPackingWrapper<TWrapped>> {
+            using Writer = TWrapped;
+        };
+    }
 }
 
 #endif //BITSERY_ADAPTER_WRITER_H

include/bitsery/bitsery.h

@@ -26,7 +26,7 @@
 
 #define BITSERY_MAJOR_VERSION 4
 #define BITSERY_MINOR_VERSION 6
-#define BITSERY_PATCH_VERSION 0
+#define BITSERY_PATCH_VERSION 1
 
 #define BITSERY_QUOTE_MACRO(name) #name
 #define BITSERY_BUILD_VERSION_STR(major,minor, patch) \

include/bitsery/deserializer.h

@@ -102,6 +102,13 @@ namespace bitsery {
             archive(std::forward<TArgs>(tail)...);
         }
 
+        template <typename T, typename... TArgs>
+        BasicDeserializer &operator()(T &&head, TArgs &&... tail) {
+            details::ArchiveFunction<BasicDeserializer, T>::invoke(*this, std::forward<T>(head));
+            archive(std::forward<TArgs>(tail)...);
+            return *this;
+        }
+
         /*
          * value
          */
@@ -331,6 +338,8 @@ namespace bitsery {
 
     private:
         friend AdapterAccess;
+        // this is required when creating bitpacking serializer, to access internal context
+        friend class BasicDeserializer<typename details::GetNonWrappedAdapterReader<TAdapterReader>::Reader, TContext>;
 
         TAdapterReader _reader;
         TContext* _context;
@@ -406,7 +415,10 @@ namespace bitsery {
         void procEnableBitPacking(const Fnc& fnc, std::false_type) {
             //create serializer using bitpacking wrapper
             BPEnabledType tmp(_reader, _context);
+            // move internal context to and from of bitpacking enabled serializer
+            tmp._internalContext = std::move(_internalContext);
             fnc(tmp);
+            _internalContext = std::move(tmp._internalContext);
         }
 
         //these are dummy functions for extensions that have TValue = void

include/bitsery/serializer.h

@@ -100,6 +100,13 @@ namespace bitsery {
             archive(std::forward<TArgs>(tail)...);
         }
 
+        template <typename T, typename... TArgs>
+        BasicSerializer &operator()(T &&head, TArgs &&... tail) {
+            details::ArchiveFunction<BasicSerializer, T>::invoke(*this, std::forward<T>(head));
+            archive(std::forward<TArgs>(tail)...);
+            return *this;
+        }
+
         /*
          * value overloads
          */
@@ -328,11 +335,14 @@ namespace bitsery {
 
     private:
         friend AdapterAccess;
+        // this is required when creating bitpacking serializer, to access internal context
+        friend class BasicSerializer<typename details::GetNonWrappedAdapterWriter<TAdapterWriter>::Writer, TContext>;
 
         TAdapterWriter _writer;
         TContext* _context;
         typename TWriter::TConfig::InternalContext _internalContext;
 
+
         //process value types
         //false_type means that we must process all elements individually
         template<size_t VSIZE, typename It>
@@ -397,7 +407,10 @@ namespace bitsery {
         void procEnableBitPacking(const Fnc& fnc, std::false_type) {
             //create serializer using bitpacking wrapper
             BPEnabledType tmp(_writer, _context);
+            // move internal context to and from of bitpacking enabled serializer
+            tmp._internalContext = std::move(_internalContext);
             fnc(tmp);
+            _internalContext = std::move(tmp._internalContext);
         }
 
         //these are dummy functions for extensions that have TValue = void
@@ -416,6 +429,7 @@ namespace bitsery {
 
     };
 
+
     //helper type
     template <typename Adapter>
     using Serializer = BasicSerializer<AdapterWriter<Adapter, DefaultConfig>>;

tests/serialization_context.cpp

@@ -130,4 +130,32 @@ TEST(SerializationContext, ContextIfExistsReturnsNullWhenTypeDoesntExists) {
     DeserializerConfigWithContext<double, int, char> des{InputAdapter{buf.begin(), 1}, &extCtx2};
     EXPECT_THAT(des.contextOrNull<double>(), ::testing::NotNull());
     EXPECT_THAT(des.contextOrNull<float>(), ::testing::IsNull());
-}
+}
+
+TEST(SerializationContext, WhenBitPackingIsEnabledThenInternalContextIsMovedToNewInstanceAndMovedBackAfterwards) {
+  Buffer buf{};
+  using Ser = SerializerConfigWithContext<void, int>;
+  using BPSer = typename Ser::BPEnabledType;
+
+  using Des = DeserializerConfigWithContext<void, int>;
+  using BPDes = typename Des::BPEnabledType;
+
+  Ser ser{buf, nullptr};
+  *ser.context<int>() = 1;
+  EXPECT_THAT(*ser.context<int>(), Eq(1));
+  ser.enableBitPacking([](BPSer& s) {
+    EXPECT_THAT(*s.context<int>(), Eq(1));
+    *s.context<int>() = 2;
+  });
+  EXPECT_THAT(*ser.context<int>(), Eq(2));
+
+  Des des{InputAdapter{buf.begin(), 1}, nullptr};
+  *des.context<int>() = 3;
+  EXPECT_THAT(*des.context<int>(), Eq(3));
+  des.enableBitPacking([](BPDes& d) {
+    EXPECT_THAT(*d.context<int>(), Eq(3));
+    *d.context<int>() = 4;
+  });
+  EXPECT_THAT(*des.context<int>(), Eq(4));
+
+}