Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-10-24 01:30:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

added inheritance extension, and ability to have internal contexts within serializer/deserializer

Browse Source
This commit is contained in:
fraillt
2017-11-06 11:30:14 +02:00
committed by Mindaugas Vinkelis
parent be9ccf08d9
commit f6d02aba38
27 changed files with 1178 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/bitsery/adapter/buffer.h
View File

@@ -21,8 +21,8 @@
//SOFTWARE.
#ifndef BITSERY_ADAPTERS_INPUT_BUFFER_ADAPTER_H
#define BITSERY_ADAPTERS_INPUT_BUFFER_ADAPTER_H
#ifndef BITSERY_ADAPTER_BUFFER_H
#define BITSERY_ADAPTER_BUFFER_H
#include "../details/adapter_common.h"
#include "../traits/core/traits.h"
@@ -204,4 +204,4 @@ namespace bitsery {
}
#endif //BITSERY_ADAPTERS_INPUT_BUFFER_ADAPTER_H
#endif //BITSERY_ADAPTER_BUFFER_H

6
include/bitsery/adapter/stream.h
View File

@@ -21,8 +21,8 @@
//SOFTWARE.
#ifndef BITSERY_ADAPTERS_DYNAMIC_STREAM_H
#define BITSERY_ADAPTERS_DYNAMIC_STREAM_H
#ifndef BITSERY_ADAPTER_STREAM_H
#define BITSERY_ADAPTER_STREAM_H
#include "../details/adapter_common.h"
#include "../traits/array.h"
@@ -224,4 +224,4 @@ namespace bitsery {
using OutputBufferedStreamAdapter = BasicBufferedOutputStreamAdapter<char, std::char_traits<char>>;
}
#endif //BITSERY_ADAPTERS_DYNAMIC_STREAM_H
#endif //BITSERY_ADAPTER_STREAM_H

9
include/bitsery/adapter_reader.h
View File

@@ -22,8 +22,8 @@
#ifndef BITSERY_BASIC_READER_H
#define BITSERY_BASIC_READER_H
#ifndef BITSERY_ADAPTER_READER_H
#define BITSERY_ADAPTER_READER_H
#include "details/sessions.h"
#include <algorithm>
@@ -39,7 +39,7 @@ namespace bitsery {
struct AdapterReader {
//this is required by deserializer
static constexpr bool BitPackingEnabled = false;
using TConfig = Config;
using TValue = typename InputAdapter::TValue;
static_assert(details::IsDefined<TValue>::value, "Please define adapter traits or include from <bitsery/traits/...>");
@@ -154,6 +154,7 @@ namespace bitsery {
public:
//this is required by deserializer
static constexpr bool BitPackingEnabled = true;
using TConfig = typename TReader::TConfig;
//make TValue unsigned for bitpacking
using UnsignedValue = typename std::make_unsigned<typename TReader::TValue>::type;
using ScratchType = typename details::ScratchType<UnsignedValue>::type;
@@ -268,4 +269,4 @@ namespace bitsery {
};
}
#endif //BITSERY_BUFFER_READER_H
#endif //BITSERY_ADAPTER_READER_H

16
include/bitsery/adapter_writer.h
View File

@@ -22,8 +22,8 @@
#ifndef BITSERY_BASIC_WRITER_H
#define BITSERY_BASIC_WRITER_H
#ifndef BITSERY_ADAPTER_WRITER_H
#define BITSERY_ADAPTER_WRITER_H
#include "details/sessions.h"
@@ -33,10 +33,12 @@
namespace bitsery {
struct MeasureSize {
template <typename Config>
struct BasicMeasureSize {
//measure class is bit-packing enabled, no need to create wrapper for it
static constexpr bool BitPackingEnabled = true;
using TConfig = Config;
template<size_t SIZE, typename T>
void writeBytes(const T &) {
static_assert(std::is_integral<T>(), "");
@@ -95,6 +97,9 @@ namespace bitsery {
size_t _sessionsBytesCount{};
};
//helper type for default config
using MeasureSize = BasicMeasureSize<DefaultConfig>;
template <typename TWriter>
class AdapterWriterBitPackingWrapper;
@@ -103,7 +108,7 @@ namespace bitsery {
struct AdapterWriter {
//this is required by serializer
static constexpr bool BitPackingEnabled = false;
using TConfig = Config;
using TValue = typename OutputAdapter::TValue;
static_assert(details::IsDefined<TValue>::value, "Please define adapter traits or include from <bitsery/traits/...>");
@@ -207,6 +212,7 @@ namespace bitsery {
public:
//this is required by serializer
static constexpr bool BitPackingEnabled = true;
using TConfig = typename TWriter::TConfig;
//make TValue unsigned for bit packing
using UnsignedType = typename std::make_unsigned<typename TWriter::TValue>::type;
@@ -334,4 +340,4 @@ namespace bitsery {
};
}
#endif //BITSERY_BASIC_WRITER_H
#endif //BITSERY_ADAPTER_WRITER_H

2
include/bitsery/bitsery.h
View File

@@ -25,7 +25,7 @@
#define BITSERY_BITSERY_H
#define BITSERY_MAJOR_VERSION 4
#define BITSERY_MINOR_VERSION 1
#define BITSERY_MINOR_VERSION 2
#define BITSERY_PATCH_VERSION 0
#define BITSERY_QUOTE_MACRO(name) #name

7
include/bitsery/common.h
View File

@@ -24,6 +24,8 @@
#ifndef BITSERY_COMMON_H
#define BITSERY_COMMON_H
#include <tuple>
namespace bitsery {
/*
@@ -41,7 +43,10 @@ namespace bitsery {
//this functionality allows to support backward/forward compatibility
//however reading from streams is not supported, because this functionality requires random access to buffer.
static constexpr bool BufferSessionsEnabled = false;
//list of contexts that will be instanciated internally within serializer/deserializer.
//contexts must be default constructable.
//internal context has priority, if external context with the same type exists.
using InternalContext = std::tuple<>;
};
}

14
include/bitsery/deserializer.h
View File

@@ -40,11 +40,14 @@ namespace bitsery {
using BPEnabledType = BasicDeserializer<typename std::conditional<TAdapterReader::BitPackingEnabled,
TAdapterReader, AdapterReaderBitPackingWrapper<TAdapterReader>>::type, TContext>;
static_assert(details::IsSpecializationOf<typename TReader::TConfig::InternalContext, std::tuple>::value,
"Config::InternalContext must be std::tuple");
template <typename ReaderParam>
explicit BasicDeserializer(ReaderParam&& r, TContext* context = nullptr)
: _reader{std::forward<ReaderParam>(r)},
_context{context}
_context{context},
_internalContext{}
{
}
@@ -66,7 +69,12 @@ namespace bitsery {
template <typename T>
T* context(){
return details::getContext<T>(_context);
return details::getContext<T>(_context, _internalContext);
}
template <typename T>
T* contextOrNull(){
return details::getContextIfTypeExists<T>(_context, _internalContext);
}
/*
@@ -326,6 +334,8 @@ namespace bitsery {
TAdapterReader _reader;
TContext* _context;
typename TReader::TConfig::InternalContext _internalContext;
//process value types
//false_type means that we must process all elements individually

6
include/bitsery/details/adapter_common.h
View File

@@ -20,8 +20,8 @@
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
#ifndef BITSERY_DETAILS_BUFFER_COMMON_H
#define BITSERY_DETAILS_BUFFER_COMMON_H
#ifndef BITSERY_DETAILS_ADAPTER_COMMON_H
#define BITSERY_DETAILS_ADAPTER_COMMON_H
#include <algorithm>
#include <utility>
@@ -124,4 +124,4 @@ namespace bitsery {
}
#endif //BITSERY_DETAILS_BUFFER_COMMON_H
#endif //BITSERY_DETAILS_ADAPTER_COMMON_H

6
include/bitsery/details/adapter_utils.h
View File

@@ -20,8 +20,8 @@
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
#ifndef BITSERY_DETAILS_BOTH_COMMON_H
#define BITSERY_DETAILS_BOTH_COMMON_H
#ifndef BITSERY_DETAILS_ADAPTER_UTILS_H
#define BITSERY_DETAILS_ADAPTER_UTILS_H
#include <cassert>
#include <cstdint>
@@ -84,4 +84,4 @@ namespace bitsery {
}
}
#endif //BITSERY_DETAILS_BOTH_COMMON_H
#endif //BITSERY_DETAILS_ADAPTER_UTILS_H

6
include/bitsery/details/not_defined_type.h
View File

@@ -21,8 +21,8 @@
//SOFTWARE.
#ifndef BITSERY_TRAITS_CORE_NOT_DEFINED_TYPE_H
#define BITSERY_TRAITS_CORE_NOT_DEFINED_TYPE_H
#ifndef BITSERY_DETAILS_NOT_DEFINED_TYPE_H
#define BITSERY_DETAILS_NOT_DEFINED_TYPE_H
#include <iterator>
@@ -76,4 +76,4 @@ namespace std {
using iterator_category = std::random_access_iterator_tag;
};
}
#endif //BITSERY_TRAITS_CORE_NOT_DEFINED_TYPE_H
#endif //BITSERY_DETAILS_NOT_DEFINED_TYPE_H

341
include/bitsery/details/serialization_common.h
View File

@@ -41,18 +41,33 @@ namespace bitsery {
}
};
//when call to serialize function is ambiguous (member and non-member serialize function exists for a type)
//specialize this class, by inheriting from either UseNonMemberFnc or UseMemberFnc
//e.g.
//template <> struct SelectSerializeFnc<MyDerivedClass>:UseMemberFnc {};
template<typename T>
struct SelectSerializeFnc : std::integral_constant<int, 0> {
};
//types you need to inherit from when specializing SelectSerializeFnc class
struct UseNonMemberFnc : std::integral_constant<int, 1> {
};
struct UseMemberFnc : std::integral_constant<int, 2> {
};
//serializer/deserializer, does not public interface to get underlying writer/reader
//to prevent users from using writer/reader directly, because they have different interface
//and they cannot be used describing serialization flows.: use extensions for this reason.
//this class allows to get underlying adapter writer/reader, and only should be used outside serialization functions.
struct AdapterAccess {
template <typename Serializer>
static typename Serializer::TWriter& getWriter(Serializer& s) {
template<typename Serializer>
static typename Serializer::TWriter &getWriter(Serializer &s) {
return s._writer;
}
template <typename Deserializer>
static typename Deserializer::TReader& getReader(Deserializer& s) {
template<typename Deserializer>
static typename Deserializer::TReader &getReader(Deserializer &s) {
return s._reader;
}
};
@@ -60,101 +75,104 @@ namespace bitsery {
namespace details {
//helper types for error handling
template <typename T>
struct IsContainerTraitsDefined:public IsDefined<typename traits::ContainerTraits<T>::TValue> {
template<typename T>
struct IsContainerTraitsDefined : public IsDefined<typename traits::ContainerTraits<T>::TValue> {
};
template <typename T>
struct IsTextTraitsDefined:public IsDefined<typename traits::TextTraits<T>::TValue> {
template<typename T>
struct IsTextTraitsDefined : public IsDefined<typename traits::TextTraits<T>::TValue> {
};
template <typename Ext, typename T>
struct IsExtensionTraitsDefined:public IsDefined<typename traits::ExtensionTraits<Ext, T>::TValue> {
template<typename Ext, typename T>
struct IsExtensionTraitsDefined : public IsDefined<typename traits::ExtensionTraits<Ext, T>::TValue> {
};
#ifdef _MSC_VER
//helper types for HasSerializeFunction
template <typename S, typename T>
using TrySerializeFunction = decltype(serialize(std::declval<S &>(), std::declval<T &>()));
//helper types for HasSerializeFunction
template <typename S, typename T>
using TrySerializeFunction = decltype(serialize(std::declval<S &>(), std::declval<T &>()));
template <typename S, typename T>
struct HasSerializeFunctionHelper {
template <typename Q, typename R, typename = TrySerializeFunction<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct HasSerializeFunction :HasSerializeFunctionHelper<S, T>::type {};
template <typename S, typename T>
struct HasSerializeFunctionHelper {
template <typename Q, typename R, typename = TrySerializeFunction<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct HasSerializeFunction :HasSerializeFunctionHelper<S, T>::type {};
//helper types for HasSerializeMethod
template <typename S, typename T>
using TrySerializeMethod = decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()));
//helper types for HasSerializeMethod
template <typename S, typename T>
using TrySerializeMethod = decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()));
template <typename S, typename T>
struct HasSerializeMethodHelper {
template <typename Q, typename R, typename = TrySerializeMethod<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct HasSerializeMethod :HasSerializeMethodHelper<S, T>::type {};
template <typename S, typename T>
struct HasSerializeMethodHelper {
template <typename Q, typename R, typename = TrySerializeMethod<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct HasSerializeMethod :HasSerializeMethodHelper<S, T>::type {};
//helper types for IsFlexibleIncluded
template <typename S, typename T>
using TryArchiveProcess = decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()));
//helper types for IsFlexibleIncluded
template <typename S, typename T>
using TryArchiveProcess = decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()));
template <typename S, typename T>
struct IsFlexibleIncludedHelper {
template <typename Q, typename R, typename = TryArchiveProcess<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct IsFlexibleIncludedHelper {
template <typename Q, typename R, typename = TryArchiveProcess<Q, R>>
static std::true_type tester(Q&&, R&&);
static std::false_type tester(...);
using type = decltype(tester(std::declval<S>(), std::declval<T>()));
};
template <typename S, typename T>
struct IsFlexibleIncluded :IsFlexibleIncludedHelper<S, T>::type {};
template <typename S, typename T>
struct IsFlexibleIncluded :IsFlexibleIncludedHelper<S, T>::type {};
#else
//helper metafunction, that is added to c++17
template<typename... Ts>
struct make_void {
typedef void type;
};
template<typename... Ts>
using void_t = typename make_void<Ts...>::type;
//helper metafunction, that is added to c++17
template<typename... Ts>
struct make_void {
typedef void type;
};
template<typename... Ts>
using void_t = typename make_void<Ts...>::type;
template <typename, typename, typename = void>
struct HasSerializeFunction :std::false_type {};
template<typename, typename, typename = void>
struct HasSerializeFunction : std::false_type {
};
template <typename S, typename T>
struct HasSerializeFunction<S, T,
void_t<decltype(serialize(std::declval<S &>(), std::declval<T &>()))>
> : std::true_type {};
template<typename S, typename T>
struct HasSerializeFunction<S, T,
void_t<decltype(serialize(std::declval<S &>(), std::declval<T &>()))>
> : std::true_type {
};
template <typename, typename, typename = void>
struct HasSerializeMethod :std::false_type {};
template<typename, typename, typename = void>
struct HasSerializeMethod : std::false_type {
};
template <typename S, typename T>
struct HasSerializeMethod<S, T,
void_t<decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()))>
> : std::true_type {};
template<typename S, typename T>
struct HasSerializeMethod<S, T,
void_t<decltype(Access::serialize(std::declval<S &>(), std::declval<T &>()))>
> : std::true_type {
};
//this solution doesn't work with visual studio, but is more elegant
template <typename, typename, typename = void>
struct IsFlexibleIncluded :std::false_type {};
//this solution doesn't work with visual studio, but is more elegant
template<typename, typename, typename = void>
struct IsFlexibleIncluded : std::false_type {
};
template <typename S, typename T>
struct IsFlexibleIncluded<S, T,
void_t<decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()))>
> : std::true_type {};
template<typename S, typename T>
struct IsFlexibleIncluded<S, T,
void_t<decltype(archiveProcess(std::declval<S &>(), std::declval<T &&>()))>
> : std::true_type {
};
#endif
//used for extensions, when extension TValue = void
struct DummyType {
};
@@ -201,23 +219,34 @@ namespace bitsery {
struct SerializeFunction {
static void invoke(S &s, T &v) {
static_assert(HasSerializeFunction<S,T>::value || HasSerializeMethod<S,T>::value,
static_assert(HasSerializeFunction<S, T>::value || HasSerializeMethod<S, T>::value,
"\nPlease define 'serialize' function for your type (inside or outside of class):\n"
" template<typename S>\n"
" void serialize(S& s)\n"
" {\n"
" ...\n"
" }\n");
static_assert(!(HasSerializeFunction<S,T>::value && HasSerializeMethod<S,T>::value),
"\nPlease define only one 'serialize' function (member OR free), not both.");
internalInvoke(s,v, HasSerializeMethod<S,T>{});
using TDecayed = typename std::decay<T>::type;
selectSerializeFnc(s, v, SelectSerializeFnc<TDecayed>{});
}
private:
static void internalInvoke(S& s, T& v,std::true_type) {
Access::serialize(s,v);
static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 0>) {
static_assert(!(HasSerializeFunction<S, T>::value && HasSerializeMethod<S, T>::value),
"\nPlease define only one 'serialize' function (member OR free).\n"
"If serialization function is inherited from base class, then explicitly select correct function for your type e.g.:\n"
" template <>\n"
" struct SelectSerializeFnc<DerivedClass>:UseMemberFnc {};\n");
selectSerializeFnc(s, v, std::integral_constant<int,
HasSerializeFunction<S, T>::value ? 1 : 2>{});
}
static void internalInvoke(S& s, T& v,std::false_type) {
serialize(s,v);
static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 1>) {
serialize(s, v);
}
static void selectSerializeFnc(S &s, T &v, std::integral_constant<int, 2>) {
Access::serialize(s, v);
}
};
@@ -228,7 +257,7 @@ namespace bitsery {
template<typename S, typename T, typename Enabled = void>
struct ArchiveFunction {
static void invoke(S &s, T&& obj) {
static void invoke(S &s, T &&obj) {
static_assert(IsFlexibleIncluded<S, T>::value,
"\nPlease include '<bitsery/flexible.h>' to use 'archive' function:\n");
@@ -237,71 +266,135 @@ namespace bitsery {
};
/*
* function for getting context from serializer/deserializer
* has different behaviour when context is tuple
* helper function for getting context from serializer/deserializer
*/
template <typename T, template <typename...> class Template>
struct IsSpecializationOf : std::false_type
{};
template<typename T, template<typename...> class Template>
struct IsSpecializationOf : std::false_type {
};
template <template <typename...> class Template, typename... Args>
struct IsSpecializationOf<Template<Args...>, Template> : std::true_type
{};
template<template<typename...> class Template, typename... Args>
struct IsSpecializationOf<Template<Args...>, Template> : std::true_type {
};
//helper types for better error messages
template <typename Find, typename ... TList>
struct GetTypeIndex:std::integral_constant<size_t, 0>
{};
template<typename Find, typename ... TList>
struct GetTypeIndex : std::integral_constant<size_t, 0> {
};
//found it
template <typename Find, typename ... Tail>
struct GetTypeIndex<Find, Find, Tail...> :std::integral_constant<size_t, 0>
{};
template<typename Find, typename ... Tail>
struct GetTypeIndex<Find, Find, Tail...> : std::integral_constant<size_t, 0> {
};
//iteratates over types
template <typename Find, typename Head, typename ... Tail>
struct GetTypeIndex<Find, Head, Tail...> :std::integral_constant<size_t, 1 + GetTypeIndex<Find, Tail...>::value>
{};
template<typename Find, typename Head, typename ... Tail>
struct GetTypeIndex<Find, Head, Tail...> : std::integral_constant<size_t,
1 + GetTypeIndex<Find, Tail...>::value> {
};
template <typename Find, typename ... TList>
struct HasType: std::integral_constant<bool, (GetTypeIndex<Find, TList...>::value < (sizeof ... (TList)))>
{};
template<typename Find, typename ... TList>
struct HasType : std::integral_constant<bool, (GetTypeIndex<Find, TList...>::value<(sizeof ... (TList)))> {
};
template<typename TCast, typename Tuple>
struct HasContext : std::is_same<TCast, Tuple> {
};
//when context is tuple, then get object from tuple
#if __cplusplus >= 201402L
template <typename TCast, typename ... Args>
TCast* getContextImpl(std::tuple<Args...>* ctx, std::true_type) {
static_assert(HasType<TCast, Args...>::value, "Invalid context cast from tuple. Type doesn't exists.");
return std::addressof(std::get<TCast>(*ctx));
}
#else
//c++11 doesn't have std::get<type> overload for getting tuple element, so we need to write our selves
template<typename TCast, typename ... Args>
struct HasContext<TCast, std::tuple<Args...>> : HasType<TCast, Args...> {
};
template <typename TCast, typename ... Args>
TCast* getContextImpl(std::tuple<Args...>* ctx, std::true_type) {
/*
* get context, and static assert if type doesn't exists
*/
template<typename TCast, typename ... Args>
TCast *getContextImpl(std::tuple<Args...> *ctx, std::true_type) {
using TCastIndex = GetTypeIndex<TCast, Args...>;
static_assert(HasType<TCast, Args...>::value, "Invalid context cast from tuple. Type doesn't exists.");
static_assert(HasType<TCast, Args...>::value, "Invalid context cast. Type doesn't exists.");
return std::addressof(std::get<TCastIndex::value>(*ctx));
}
#endif
template <typename TCast, typename TContext>
TCast* getContextImpl(TContext* ctx, std::false_type) {
static_assert(std::is_convertible<TContext*, TCast*>::value, "Invalid context cast");
return static_cast<TCast*>(ctx);
template<typename TCast, typename TContext>
TCast *getContextImpl(TContext *ctx, std::false_type) {
static_assert(std::is_convertible<TContext *, TCast *>::value, "Invalid context cast. Type doesn't exists.");
return static_cast<TCast *>(ctx);
}
template <typename TCast, typename TContext>
TCast* getContext(TContext* ctx) {
//get local ctx
template<typename TCast, typename TContext, typename TInternalContext>
TCast *chooseInternalOrExternalContext(TContext *, TInternalContext &internalCtx, std::true_type) {
return getContextImpl<TCast>(&internalCtx, std::true_type{});
}
//get external ctx
template<typename TCast, typename TContext, typename TInternalContext>
TCast *chooseInternalOrExternalContext(TContext *ctx, TInternalContext &, std::false_type) {
return ctx
? getContextImpl<TCast>(ctx, IsSpecializationOf<TContext, std::tuple>{})
: nullptr;
}
}
template<typename TCast, typename TContext, typename TInternalContext>
TCast *getContext(TContext *ctx, TInternalContext &internalCtx) {
return chooseInternalOrExternalContext<TCast>(ctx, internalCtx, HasContext<TCast, TInternalContext>{});
}
/*
* get context, if type doesn't exists then do not static_assert but return null instead
*/
template<typename TCast, typename TContext>
TCast *getContextFromTypeIfExists(TContext *ctx, std::true_type) {
return static_cast<TCast *>(ctx);
}
template<typename TCast, typename TContext>
TCast *getContextFromTypeIfExists(TContext *, std::false_type) {
return nullptr;
}
template<typename TCast, typename TContext>
TCast *getContextImplIfExists(TContext *ctx, std::false_type) {
return getContextFromTypeIfExists<TCast>(ctx, std::is_convertible<TContext *, TCast *>{});
}
template<typename TCast, typename TContext>
TCast *getContextFromTupleIfExists(TContext *ctx, std::true_type tmp) {
return getContextImpl<TCast>(ctx, tmp);
}
template<typename TCast, typename TContext>
TCast *getContextFromTupleIfExists(TContext *, std::false_type) {
return nullptr;
}
template<typename TCast, typename TContext>
TCast *getContextImplIfExists(TContext *ctx, std::true_type) {
return getContextFromTupleIfExists<TCast>(ctx, HasContext<TCast, TContext>{});
}
//get local ctx
template<typename TCast, typename TContext, typename TInternalContext>
TCast *chooseInternalOrExternalContextIfExists(TContext *, TInternalContext &internalCtx, std::true_type) {
return getContextImplIfExists<TCast>(&internalCtx, std::true_type{});
}
//get external ctx
template<typename TCast, typename TContext, typename TInternalContext>
TCast *chooseInternalOrExternalContextIfExists(TContext *ctx, TInternalContext &, std::false_type) {
return ctx
? getContextImplIfExists<TCast>(ctx, IsSpecializationOf<TContext, std::tuple>{})
: nullptr;
}
template<typename TCast, typename TContext, typename TInternalContext>
TCast *getContextIfTypeExists(TContext *ctx, TInternalContext &internalCtx) {
return chooseInternalOrExternalContextIfExists<TCast>(ctx, internalCtx, HasContext<TCast, TInternalContext>{});
}
}
}
#endif //BITSERY_DETAILS_SERIALIZATION_COMMON_H

6
include/bitsery/details/sessions.h
View File

@@ -2,8 +2,8 @@
// Created by fraillt on 17.10.5.
//
#ifndef BITSERY_BUFFER_SESSIONS_H
#define BITSERY_BUFFER_SESSIONS_H
#ifndef BITSERY_DETAILS_SESSIONS_H
#define BITSERY_DETAILS_SESSIONS_H
#include <vector>
#include <stack>
@@ -225,4 +225,4 @@ namespace bitsery {
}
}
#endif //BITSERY_BUFFER_SESSIONS_H
#endif //BITSERY_DETAILS_SESSIONS_H

2
include/bitsery/ext/growable.h
View File

@@ -23,6 +23,8 @@
#ifndef BITSERY_EXT_GROWABLE_H
#define BITSERY_EXT_GROWABLE_H
#include "../traits/core/traits.h"
namespace bitsery {
namespace ext {

156
include/bitsery/ext/inheritance.h Normal file
View File

@@ -0,0 +1,156 @@
//MIT License
//
//Copyright (c) 2017 Mindaugas Vinkelis
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
#ifndef BITSERY_EXT_INHERITANCE_H
#define BITSERY_EXT_INHERITANCE_H
#include <unordered_set>
#include "../traits/core/traits.h"
namespace bitsery {
namespace ext {
//required when virtual inheritance (ext::VirtualBaseClass) exists in serialization flow.
//for standard inheritance (ext::BaseClass) it is optional.
class InheritanceContext {
public:
InheritanceContext() = default;
InheritanceContext(const InheritanceContext&) = delete;
InheritanceContext&operator = (const InheritanceContext&) = delete;
InheritanceContext(InheritanceContext&&) = default;
InheritanceContext& operator = (InheritanceContext&&) = default;
template <typename TDerived, typename TBase>
void beginBase(const TDerived &derived, const TBase &) {
if (_depth == 0) {
const void* ptr = std::addressof(derived);
if ( _parentPtr != ptr)
_virtualBases.clear();
_parentPtr = ptr;
}
++_depth;
}
template <typename TDerived, typename TBase>
bool beginVirtualBase(const TDerived &derived, const TBase &base) {
beginBase(derived, base);
return _virtualBases.emplace(std::addressof(base)).second;
}
void end() {
--_depth;
}
private:
//these members are required to know when we can clear _virtualBases
size_t _depth{};
const void* _parentPtr{};
//add virtual bases to the list, as long as we're on the same parent
std::unordered_set<const void*> _virtualBases{};
};
template <typename TBase>
class BaseClass {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
auto& resObj = static_cast<const TBase&>(obj);
if (auto ctx = ser.template contextOrNull<InheritanceContext>()) {
ctx->beginBase(obj, resObj);
fnc(const_cast<TBase&>(resObj));
ctx->end();
} else {
fnc(const_cast<TBase&>(resObj));
}
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
auto& resObj = static_cast<TBase&>(obj);
if (auto ctx = des.template contextOrNull<InheritanceContext>()) {
ctx->beginBase(obj, resObj);
fnc(resObj);
ctx->end();
} else {
fnc(resObj);
}
}
};
//requires InheritanceContext
template <typename TBase>
class VirtualBaseClass {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
auto ctx = ser.template context<InheritanceContext>();
auto& resObj = static_cast<const TBase&>(obj);
if (ctx->beginVirtualBase(obj, resObj))
fnc(const_cast<TBase&>(resObj));
ctx->end();
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
auto ctx = des.template context<InheritanceContext>();
auto& resObj = static_cast<TBase&>(obj);
if (ctx->beginVirtualBase(obj, resObj))
fnc(resObj);
ctx->end();
}
};
}
namespace traits {
template<typename TBase, typename T>
struct ExtensionTraits<ext::BaseClass<TBase>, T> {
static_assert(std::is_base_of<TBase, T>::value, "Invalid base class");
using TValue = TBase;
static constexpr bool SupportValueOverload = false;
static constexpr bool SupportObjectOverload = true;
static constexpr bool SupportLambdaOverload = true;
};
template<typename TBase, typename T>
struct ExtensionTraits<ext::VirtualBaseClass<TBase>, T> {
static_assert(std::is_base_of<TBase, T>::value, "Invalid base class");
using TValue = TBase;
static constexpr bool SupportValueOverload = false;
static constexpr bool SupportObjectOverload = true;
//disable lambda overload, when serializing virtually inherited base class.
//Only one instance of virtual base will be serialized, when using multiple inheritance
//and it will be undefined behaviour if derived classes would have different virtual base class serialization flow.
static constexpr bool SupportLambdaOverload = false;
};
}
}
#endif //BITSERY_EXT_INHERITANCE_H

302
include/bitsery/ext/pointer.h
View File

@@ -23,6 +23,8 @@
#ifndef BITSERY_EXT_POINTER_H
#define BITSERY_EXT_POINTER_H
#include "../traits/core/traits.h"
#include <unordered_map>
#include <vector>
#include <memory>
@@ -34,21 +36,93 @@ namespace bitsery {
//forward declare
class PointerLinkingContext;
enum PointerType {
enum class PointerType {
Nullable,
NotNull
};
enum class PointerOwnershipType:uint8_t {
//is not responsible for pointer lifetime management.
Observer,
//only ONE owner is responsible for this pointers creation/destruction
Owner,
//MANY shared owners is responsible for pointer creation/destruction
//requires additional context to manage shared owners themselves.
Shared
};
namespace details_pointer {
enum class PointerOwnershipType:uint8_t {
//is not responsible for pointer lifetime management.
Observer,
//only ONE owner is responsible for this pointers creation/destruction
Owner,
//MANY shared owners is responsible for pointer creation/destruction
//requires additional context to manage shared owners themselves.
Shared
//helper functions that creates or destroys pointers
//useful, because can be specialized
template <typename T>
void destroyObject(T &ptr) {
if (ptr) {
delete ptr;
}
ptr = nullptr;
}
template <typename T>
void createObject(T &ptr) {
using TNonPtr = typename std::remove_pointer<T>::type;
if (ptr == nullptr)
ptr = new TNonPtr{};
}
template <typename S, typename TPtr>
void serializeObject(S &s, const TPtr &obj) {
using TNonPtr = typename std::remove_pointer<TPtr>::type;
static_assert(!std::is_polymorphic<TNonPtr>::value, "Polymorphic types are not supported");
serializeImpl(s, *obj, details::IsFundamentalType<TNonPtr>{});
}
template <typename S, typename T>
void serializeImpl(S& s, const T& obj, std::true_type) {
s.template value<sizeof(T)>(obj);
}
template <typename S, typename T>
void serializeImpl(S& s, const T& obj, std::false_type) {
s.object(obj);
}
template <typename S, typename TPtr>
void deserializeObject(S &s, TPtr &obj) {
using TNonPtr = typename std::remove_pointer<TPtr>::type;
static_assert(!std::is_polymorphic<TNonPtr>::value, "Polymorphic types are not supported");
deserializeImpl(s, *obj, details::IsFundamentalType<TNonPtr>{});
}
template <typename S, typename T>
void deserializeImpl(S& s, T& obj, std::true_type) {
s.template value<sizeof(T)>(obj);
}
template <typename S, typename T>
void deserializeImpl(S& s, T& obj, std::false_type) {
s.object(obj);
}
class RawPointerManager {
public:
template <typename Writer, typename Ser, typename T>
static void serializeObject(Writer& , Ser& ser, const T& obj) {
details_pointer::serializeObject(ser, obj);
}
template <typename Reader, typename Des, typename T>
static void deserializeObject(Reader& , Des& des, T& obj) {
details_pointer::createObject(obj);
details_pointer::deserializeObject(des, obj);
}
template <typename T>
static void destroyObject(T& obj) {
details_pointer::destroyObject(obj);
}
};
class PointerLinkingContextSerialization {
@@ -65,36 +139,37 @@ namespace bitsery {
PointerLinkingContextSerialization& operator = (PointerLinkingContextSerialization&&) = default;
~PointerLinkingContextSerialization() = default;
struct PointerInfo {
PointerInfo(size_t id_, PointerOwnershipType ownershipType_)
:id{id_},
ownershipType{ownershipType_},
sharedCount{0}
{};
size_t id;
PointerOwnershipType ownershipType;
size_t sharedCount;
};
size_t createId(const void *ptr, PointerOwnershipType ptrType) {
if (ptr == nullptr)
return 0u;
const PointerInfo& getInfoByPtr(const void *ptr, PointerOwnershipType ptrType) {
auto res = _ptrMap.emplace(ptr, PointerInfo{_currId + 1u, ptrType});
auto& ptrInfo = res.first->second;
if (res.second) {
++_currId;
return ptrInfo.id;
return ptrInfo;
}
//ptr already exists
//for observer return success
if (ptrType == PointerOwnershipType::Observer)
return ptrInfo.id;
return ptrInfo;
//set owner and return success
if (ptrInfo.ownershipType == PointerOwnershipType::Observer) {
ptrInfo.ownershipType = ptrType;
return ptrInfo.id;
return ptrInfo;
}
//only shared ownership can get here multiple times
assert(ptrType == PointerOwnershipType::Shared);
return ptrInfo.id;
}
template <typename S, typename TPtr>
void serialize(S& s, const TPtr& obj) {
using TNonPtr = typename std::remove_pointer<TPtr>::type;
static_assert(!std::is_polymorphic<TNonPtr>::value, "Polymorphic types are not supported");
serializeImpl(s, *obj, details::IsFundamentalType<TNonPtr>{});
ptrInfo.sharedCount++;
return ptrInfo;
}
//valid, when all pointers have owners.
@@ -106,25 +181,6 @@ namespace bitsery {
}
private:
template <typename S, typename T>
void serializeImpl(S& s, const T& obj, std::true_type) {
s.template value<sizeof(T)>(obj);
}
template <typename S, typename T>
void serializeImpl(S& s, const T& obj, std::false_type) {
s.object(obj);
}
struct PointerInfo {
PointerInfo(size_t id_, PointerOwnershipType ownershipType_)
:id{id_},
ownershipType{ownershipType_}
{};
size_t id;
PointerOwnershipType ownershipType;
};
size_t _currId;
std::unordered_map<const void*, PointerInfo> _ptrMap;
@@ -135,23 +191,6 @@ namespace bitsery {
virtual ~SharedContextBase() = default;
};
//helper functions that creates or destroys pointers
//useful, because can be specialized
template <typename T>
void destroyPointer(T& ptr) {
if (ptr) {
delete ptr;
}
ptr = nullptr;
}
template <typename T>
void createPointer(T& ptr) {
using TNonPtr = typename std::remove_pointer<T>::type;
if (ptr == nullptr)
ptr = new TNonPtr{};
}
class PointerLinkingContextDeserialization {
public:
explicit PointerLinkingContextDeserialization()
@@ -165,36 +204,52 @@ namespace bitsery {
PointerLinkingContextDeserialization& operator = (PointerLinkingContextDeserialization&&) = default;
~PointerLinkingContextDeserialization() = default;
void processOwnerPtr(size_t id, void* ptr, PointerOwnershipType ptrType) {
assert(id != 0 && ptr != nullptr && ptrType != PointerOwnershipType::Observer);
auto res = _idMap.emplace(id, PointerInfo{id, ptr, ptrType});
auto& ptrInfo = res.first->second;
if (!res.second) {
assert(ptrInfo.ownershipType != PointerOwnershipType::Owner);
//if already exists, then process observer list
if (ptrInfo.ownershipType == PointerOwnershipType::Observer) {
ptrInfo.ptrAddress = ptr;
ptrInfo.ownershipType = ptrType;
processObserverList(ptrInfo.observersList, ptr);
struct PointerInfo {
PointerInfo(size_t id_, void* ptr, PointerOwnershipType ownershipType_)
:id{id_},
ownershipType{ownershipType_},
ownerPtr{ptr},
observersList{},
sharedContext{}
{};
PointerInfo(const PointerInfo&) = delete;
PointerInfo& operator = (const PointerInfo&) = delete;
PointerInfo(PointerInfo&&) = default;
PointerInfo&operator = (PointerInfo&&) = default;
~PointerInfo() = default;
void processOwner(void* ptr) {
ownerPtr = ptr;
assert(ownershipType != PointerOwnershipType::Observer);
for (auto& o:observersList)
o.get() = ptr;
observersList.clear();
observersList.shrink_to_fit();
}
void processObserver(void* (&ptr)) {
if (ownerPtr) {
ptr = ownerPtr;
} else {
observersList.push_back(ptr);
}
}
}
size_t id;
PointerOwnershipType ownershipType;
void* ownerPtr;
std::vector<std::reference_wrapper<void*>> observersList;
std::unique_ptr<SharedContextBase> sharedContext;
};
void processObserverPtr(size_t id, void* (&ptr)) {
auto res = _idMap.emplace(id, PointerInfo{id, nullptr, PointerOwnershipType::Observer});
PointerInfo& getInfoById(size_t id, PointerOwnershipType ptrType) {
auto res = _idMap.emplace(id, PointerInfo{id, nullptr, ptrType});
auto& ptrInfo = res.first->second;
if (ptrInfo.ptrAddress)
ptr = ptrInfo.ptrAddress;
else
ptrInfo.observersList.push_back(ptr);
}
template <typename S, typename TPtr>
void deserialize(S& s, TPtr& obj) {
using TNonPtr = typename std::remove_pointer<TPtr>::type;
static_assert(!std::is_polymorphic<TNonPtr>::value, "Polymorphic types are not supported");
createPointer(obj);
deserializeImpl(s, *obj, details::IsFundamentalType<TNonPtr>{});
if (!res.second) {
assert(ptrType != PointerOwnershipType::Owner || ptrInfo.ownershipType == PointerOwnershipType::Observer);
if (ptrInfo.ownershipType == PointerOwnershipType::Observer)
ptrInfo.ownershipType = ptrType;
}
return ptrInfo;
}
//valid, when all pointers has owners
@@ -205,45 +260,6 @@ namespace bitsery {
}
private:
struct PointerInfo {
PointerInfo(size_t id_, void* ptr, PointerOwnershipType ownershipType_)
:id{id_},
ownershipType{ownershipType_},
ptrAddress{ptr},
observersList{},
sharedContext{}
{};
PointerInfo(const PointerInfo&) = delete;
PointerInfo& operator = (const PointerInfo&) = delete;
PointerInfo(PointerInfo&&) = default;
PointerInfo&operator = (PointerInfo&&) = default;
~PointerInfo() = default;
size_t id;
PointerOwnershipType ownershipType;
void* ptrAddress;
std::vector<std::reference_wrapper<void*>> observersList;
std::unique_ptr<SharedContextBase> sharedContext;
};
void processObserverList(std::vector<std::reference_wrapper<void*>>& observers, void* ptr) {
for (auto& o:observers)
o.get() = ptr;
observers.clear();
observers.shrink_to_fit();
}
template <typename S, typename T>
void deserializeImpl(S& s, T& obj, std::true_type) {
s.template value<sizeof(T)>(obj);
}
template <typename S, typename T>
void deserializeImpl(S& s, T& obj, std::false_type) {
s.object(obj);
}
std::unordered_map<size_t, PointerInfo> _idMap;
};
@@ -265,7 +281,6 @@ namespace bitsery {
}
};
class PointerOwner {
public:
explicit PointerOwner(PointerType ptrType = PointerType::Nullable):_ptrType{ptrType} {}
@@ -273,11 +288,14 @@ namespace bitsery {
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&) const {
auto& ctx = details_pointer::getLinkingContext(ser);
auto id = ctx.createId(obj, details_pointer::PointerOwnershipType::Owner);
assert(id || _ptrType == PointerType::Nullable);
details::writeSize(w, id);
if (id)
ctx.serialize(ser, obj);
if (obj) {
auto& ptrInfo = ctx.getInfoByPtr(obj, PointerOwnershipType::Owner);
details::writeSize(w, ptrInfo.id);
details_pointer::RawPointerManager::serializeObject(w, ser, obj);
} else {
assert(_ptrType == PointerType::Nullable);
details::writeSize(w, 0);
}
}
template<typename Des, typename Reader, typename T, typename Fnc>
@@ -287,11 +305,12 @@ namespace bitsery {
details::readSize(r, id, std::numeric_limits<size_t>::max());
if (id) {
auto& ctx = details_pointer::getLinkingContext(des);
ctx.deserialize(des, obj);
ctx.processOwnerPtr(id, obj, details_pointer::PointerOwnershipType::Owner);
auto& ptrInfo = ctx.getInfoById(id, PointerOwnershipType::Owner);
details_pointer::RawPointerManager::deserializeObject(r, des, obj);
ptrInfo.processOwner(obj);
} else {
if (_ptrType == PointerType::Nullable)
details_pointer::destroyPointer(obj);
details_pointer::RawPointerManager::destroyObject(obj);
else
r.setError(ReaderError::InvalidPointer);
}
@@ -308,9 +327,12 @@ namespace bitsery {
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &w, const T &obj, Fnc &&) const {
auto& ctx = details_pointer::getLinkingContext(ser);
auto id = ctx.createId(obj, details_pointer::PointerOwnershipType::Observer);
assert(id || _ptrType == PointerType::Nullable);
details::writeSize(w, id);
if (obj) {
details::writeSize(w, ctx.getInfoByPtr(obj, PointerOwnershipType::Observer).id);
} else {
assert(_ptrType == PointerType::Nullable);
details::writeSize(w, 0);
}
}
template<typename Des, typename Reader, typename T, typename Fnc>
@@ -319,7 +341,7 @@ namespace bitsery {
details::readSize(r, id, std::numeric_limits<size_t>::max());
if (id) {
auto& ctx = details_pointer::getLinkingContext(des);
ctx.processObserverPtr(id, reinterpret_cast<void*&>(obj));
ctx.getInfoById(id, PointerOwnershipType::Observer).processObserver(reinterpret_cast<void*&>(obj));
} else {
if (_ptrType == PointerType::Nullable)
obj = nullptr;
@@ -336,7 +358,7 @@ namespace bitsery {
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &w, const T &obj, Fnc && fnc) const {
auto& ctx = details_pointer::getLinkingContext(ser);
details::writeSize(w, ctx.createId(&obj, details_pointer::PointerOwnershipType::Owner));
details::writeSize(w, ctx.getInfoByPtr(&obj, PointerOwnershipType::Owner).id);
fnc(const_cast<T&>(obj));
}
@@ -347,7 +369,7 @@ namespace bitsery {
if (id) {
auto& ctx = details_pointer::getLinkingContext(des);
fnc(obj);
ctx.processOwnerPtr(id, &obj, details_pointer::PointerOwnershipType::Owner);
ctx.getInfoById(id, PointerOwnershipType::Owner).processOwner(&obj);
} else {
//cannot be null for references
r.setError(ReaderError::InvalidPointer);

1
include/bitsery/ext/std_map.h
View File

@@ -23,6 +23,7 @@
#ifndef BITSERY_EXT_STD_MAP_H
#define BITSERY_EXT_STD_MAP_H
#include "../traits/core/traits.h"
#include "../details/adapter_utils.h"
namespace bitsery {

1
include/bitsery/ext/std_optional.h
View File

@@ -33,6 +33,7 @@
// using optional = experimental::optional<T>;
//}
#include <type_traits>
#include "../traits/core/traits.h"
namespace bitsery {
namespace ext {

1
include/bitsery/ext/std_set.h
View File

@@ -27,6 +27,7 @@
#include "../details/adapter_utils.h"
//we need this, so we could
#include <unordered_set>
#include "../traits/core/traits.h"
namespace bitsery {
namespace ext {

14
include/bitsery/serializer.h
View File

@@ -39,10 +39,14 @@ namespace bitsery {
using BPEnabledType = BasicSerializer<typename std::conditional<TAdapterWriter::BitPackingEnabled,
TAdapterWriter, AdapterWriterBitPackingWrapper<TAdapterWriter>>::type, TContext>;
static_assert(details::IsSpecializationOf<typename TWriter::TConfig::InternalContext, std::tuple>::value,
"Config::InternalContext must be std::tuple");
template <typename WriterParam>
explicit BasicSerializer(WriterParam&& w, TContext* context = nullptr)
: _writer{std::forward<WriterParam>(w)},
_context{context}
_context{context},
_internalContext{}
{
}
@@ -64,7 +68,12 @@ namespace bitsery {
template <typename T>
T* context() {
return details::getContext<T>(_context);
return details::getContext<T>(_context, _internalContext);
}
template <typename T>
T* contextOrNull() {
return details::getContextIfTypeExists<T>(_context, _internalContext);
}
/*
@@ -322,6 +331,7 @@ namespace bitsery {
TAdapterWriter _writer;
TContext* _context;
typename TWriter::TConfig::InternalContext _internalContext;
//process value types
//false_type means that we must process all elements individually

6
include/bitsery/traits/core/std_defaults.h
View File

@@ -20,8 +20,8 @@
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
#ifndef BITSERY_TRAITS_HELPER_STD_DEFAULTS_H
#define BITSERY_TRAITS_HELPER_STD_DEFAULTS_H
#ifndef BITSERY_TRAITS_CORE_STD_DEFAULTS_H
#define BITSERY_TRAITS_CORE_STD_DEFAULTS_H
#include "traits.h"
#include <iostream>
@@ -82,4 +82,4 @@ namespace bitsery {
}
}
#endif //BITSERY_TRAITS_HELPER_STD_DEFAULTS_H
#endif //BITSERY_TRAITS_CORE_STD_DEFAULTS_H