Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-09-13 22:08:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

removed Reader/Writer parameter from extensions serialize/deserialize

Browse Source 
methods
This commit is contained in:
Mindaugas Vinkelis
2019-07-03 09:07:03 +03:00
committed by Mindaugas Vinkelis
parent a1785f3e15
commit ff40222124
18 changed files with 139 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@@ -5,7 +5,7 @@
* align from serializer/deserializer
* AdapterAccess class
* helper class Serializer/Deserializer
* deprecated registerBasesList from PolymorphicContext
* removed deprecated function registerBasesList from PolymorphicContext
* internal context from config, because it doesn't actually solve any problems, only allows to do same thing in multiple ways
* AdapterWriter/Reader classes, and their functionality is moved to `adapters`.
* UnsafeInputBufferAdapter, instead config option is provided to disable buffer read errors
@@ -27,6 +27,7 @@
(e.g. you can require base class of context in extension, but provided child implementation instead)
* renamed NetworkEndianness to Endianness in config
* MeasureSize adapter moved to separate file `/adapter/measure_size.h`
* removed Writer/Reader parameter from extensions serialize/deserialize methods
## improvements

7
include/bitsery/deserializer.h
View File

@@ -168,6 +168,7 @@ namespace bitsery {
using BPEnabledType = BasicDeserializer<typename std::conditional<TInputAdapter::BitPackingEnabled,
TInputAdapter,
details::InputAdapterBitPackingWrapper<TInputAdapter>>::type, TContext>;
using TConfig = typename TInputAdapter::TConfig;
using details::AdapterAndContextRef<TInputAdapter, TContext>::AdapterAndContextRef;
@@ -233,7 +234,7 @@ namespace bitsery {
static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
"extension doesn't support overload with lambda");
extension.deserialize(*this, this->_adapter, obj, std::forward<Fnc>(fnc));
extension.deserialize(*this, obj, std::forward<Fnc>(fnc));
}
template<size_t VSIZE, typename T, typename Ext>
@@ -243,7 +244,7 @@ namespace bitsery {
"extension doesn't support overload with `value<N>`");
using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
extension.deserialize(*this, this->_adapter, obj, [](BasicDeserializer& s, VType &v) { s.value<VSIZE>(v);});
extension.deserialize(*this, obj, [](BasicDeserializer& s, VType &v) { s.value<VSIZE>(v);});
}
template<typename T, typename Ext>
@@ -253,7 +254,7 @@ namespace bitsery {
"extension doesn't support overload with `object`");
using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
extension.deserialize(*this, this->_adapter, obj, [](BasicDeserializer& s, VType &v) { s.object(v); });
extension.deserialize(*this, obj, [](BasicDeserializer& s, VType &v) { s.object(v); });
}
/*

32
include/bitsery/ext/compact_value.h
View File

@@ -35,43 +35,43 @@ namespace bitsery {
class CompactValueImpl {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &s, Writer &writer, const T &v, Fnc &&) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &s, const T &v, Fnc &&) const {
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
using TValue = typename IntegralFromFundamental<T>::TValue;
serializeImpl(s, writer, reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
serializeImpl(s.adapter(), reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &d, Reader &reader, T &v, Fnc &&) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &d, T &v, Fnc &&) const {
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
using TValue = typename IntegralFromFundamental<T>::TValue;
deserializeImpl(d, reader, reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
deserializeImpl(d.adapter(), reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
}
private:
// if value is 1byte size, just serialize/ deserialize whole value
template<typename Ser, typename Writer, typename T>
void serializeImpl(Ser &s, Writer &, const T &v, std::false_type) const {
s.value1b(v);
template<typename Writer, typename T>
void serializeImpl(Writer &writer, const T &v, std::false_type) const {
writer.template writeBytes<1>(v);
}
template<typename Des, typename Reader, typename T>
void deserializeImpl(Des &d, Reader &, T &v, std::false_type) const {
d.value1b(v);
template<typename Reader, typename T>
void deserializeImpl(Reader &reader, T &v, std::false_type) const {
reader.template readBytes<1>(v);
}
// when value is bigger than 1byte size,
template<typename Ser, typename Writer, typename T>
void serializeImpl(Ser &, Writer &writer, const T &v, std::true_type) const {
template<typename Writer, typename T>
void serializeImpl(Writer &writer, const T &v, std::true_type) const {
auto val = zigZagEncode(v, std::is_signed<typename IntegralFromFundamental<T>::TValue>{});
writeBytes(writer, val);
}
template<typename Des, typename Reader, typename T>
void deserializeImpl(Des &, Reader &reader, T &v, std::true_type) const {
template<typename Reader, typename T>
void deserializeImpl(Reader &reader, T &v, std::true_type) const {
using TUnsigned = SameSizeUnsigned<T>;
TUnsigned res{};
readBytes<Reader::TConfig::CheckDataErrors>(reader, res);

12
include/bitsery/ext/entropy.h
View File

@@ -56,24 +56,24 @@ namespace bitsery {
_alignBeforeData{alignBeforeData} {
};
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &s, Writer &writer, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &s, const T &obj, Fnc &&fnc) const {
assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
auto index = details::findEntropyIndex(obj, _values);
s.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
if (_alignBeforeData)
writer.align();
s.adapter().align();
if (!index)
fnc(s, const_cast<T &>(obj));
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &d, Reader &reader, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &d, T &obj, Fnc &&fnc) const {
assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
size_t index{};
d.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
if (_alignBeforeData)
reader.align();
d.adapter().align();
if (index)
obj = *std::next(std::begin(_values), index-1);
else

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

@@ -37,8 +37,9 @@ namespace bitsery {
class Growable {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
auto& writer = ser.adapter();
const auto startPos = writer.currentWritePos();
writer.template writeBytes<4>(static_cast<uint32_t>(0));
@@ -50,8 +51,9 @@ namespace bitsery {
writer.currentWritePos(endPos);
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &obj, Fnc &&fnc) const {
auto& reader = des.adapter();
uint32_t size{};
const auto readEndPos = reader.currentReadEndPos();
const auto startPos = reader.currentReadPos();

16
include/bitsery/ext/inheritance.h
View File

@@ -79,8 +79,8 @@ namespace bitsery {
class BaseClass {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
auto& resObj = static_cast<const TBase&>(obj);
if (auto ctx = ser.template contextOrNull<InheritanceContext>()) {
ctx->beginBase(obj, resObj);
@@ -91,8 +91,8 @@ namespace bitsery {
}
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &obj, Fnc &&fnc) const {
auto& resObj = static_cast<TBase&>(obj);
if (auto ctx = des.template contextOrNull<InheritanceContext>()) {
ctx->beginBase(obj, resObj);
@@ -110,8 +110,8 @@ namespace bitsery {
class VirtualBaseClass {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
auto& ctx = ser.template context<InheritanceContext>();
auto& resObj = static_cast<const TBase&>(obj);
if (ctx.beginVirtualBase(obj, resObj))
@@ -119,8 +119,8 @@ namespace bitsery {
ctx.end();
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &obj, Fnc &&fnc) const {
auto& ctx = des.template context<InheritanceContext>();
auto& resObj = static_cast<TBase&>(obj);
if (ctx.beginVirtualBase(obj, resObj))

16
include/bitsery/ext/std_chrono.h
View File

@@ -32,14 +32,14 @@ namespace bitsery {
class StdDuration {
public:
template<typename Ser, typename Writer, typename T, typename Period, typename Fnc>
void serialize(Ser& ser, Writer&, const std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
template<typename Ser, typename T, typename Period, typename Fnc>
void serialize(Ser& ser, const std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
auto res = obj.count();
fnc(ser, res);
}
template<typename Des, typename Reader, typename T, typename Period, typename Fnc>
void deserialize(Des& des, Reader&, std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
template<typename Des, typename T, typename Period, typename Fnc>
void deserialize(Des& des, std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
T res{};
fnc(des, res);
obj = std::chrono::duration<T, Period>{res};
@@ -49,15 +49,15 @@ namespace bitsery {
class StdTimePoint {
public:
template<typename Ser, typename Writer, typename Clock, typename T, typename Period, typename Fnc>
void serialize(Ser& ser, Writer&, const std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
template<typename Ser, typename Clock, typename T, typename Period, typename Fnc>
void serialize(Ser& ser, const std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
Fnc&& fnc) const {
auto res = obj.time_since_epoch().count();
fnc(ser, res);
}
template<typename Des, typename Reader, typename Clock, typename T, typename Period, typename Fnc>
void deserialize(Des& des, Reader&, std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
template<typename Des, typename Clock, typename T, typename Period, typename Fnc>
void deserialize(Des& des, std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
Fnc&& fnc) const {
T res{};
fnc(des, res);

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

@@ -37,25 +37,26 @@ namespace bitsery {
constexpr explicit StdMap(size_t maxSize):_maxSize{maxSize} {}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
using TKey = typename T::key_type;
using TValue = typename T::mapped_type;
auto size = obj.size();
assert(size <= _maxSize);
details::writeSize(writer, size);
details::writeSize(ser.adapter(), size);
for (auto &v:obj)
fnc(ser, const_cast<TKey &>(v.first), const_cast<TValue &>(v.second));
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &obj, Fnc &&fnc) const {
using TKey = typename T::key_type;
using TValue = typename T::mapped_type;
size_t size{};
details::readSize(reader, size, _maxSize, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
details::readSize(des.adapter(), size, _maxSize,
std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
obj.clear();
reserve(obj, size);

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

@@ -40,21 +40,21 @@ namespace bitsery {
*/
explicit StdOptional(bool alignBeforeData=true):_alignBeforeData{alignBeforeData} {}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &writer, const std::optional<T> &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const std::optional<T> &obj, Fnc &&fnc) const {
ser.boolValue(static_cast<bool>(obj));
if (_alignBeforeData)
writer.align();
ser.adapter().align();
if (obj)
fnc(ser, const_cast<T&>(*obj));
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &reader, std::optional<T> &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, std::optional<T> &obj, Fnc &&fnc) const {
bool exists{};
des.boolValue(exists);
if (_alignBeforeData)
reader.align();
des.adapter().align();
if (exists) {
obj = ::bitsery::Access::create<T>();
fnc(des, *obj);

16
include/bitsery/ext/std_queue.h
View File

@@ -71,24 +71,24 @@ namespace bitsery {
explicit StdQueue(size_t maxSize):_maxSize{maxSize} {};
//for queue
template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
void serialize(Ser &ser, Writer &, const std::queue<T,C> &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename C, typename Fnc>
void serialize(Ser &ser, const std::queue<T,C> &obj, Fnc &&fnc) const {
ser.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}
template<typename Des, typename Reader, typename T, typename C, typename Fnc>
void deserialize(Des &des, Reader &, std::queue<T,C> &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename C, typename Fnc>
void deserialize(Des &des, std::queue<T,C> &obj, Fnc &&fnc) const {
des.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}
//for priority_queue
template<typename Ser, typename Writer, typename T, typename C, typename Comp, typename Fnc>
void serialize(Ser &ser, Writer &, const std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename C, typename Comp, typename Fnc>
void serialize(Ser &ser, const std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
ser.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}
template<typename Des, typename Reader, typename T, typename C, typename Comp, typename Fnc>
void deserialize(Des &des, Reader &, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename C, typename Comp, typename Fnc>
void deserialize(Des &des, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
des.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}

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

@@ -37,23 +37,23 @@ namespace bitsery {
constexpr explicit StdSet(size_t maxSize):_maxSize{maxSize} {}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
using TKey = typename T::key_type;
auto size = obj.size();
assert(size <= _maxSize);
details::writeSize(writer, size);
details::writeSize(ser.adapter(), size);
for (auto &v:obj)
fnc(ser, const_cast<TKey &>(v));
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &obj, Fnc &&fnc) const {
using TKey = typename T::key_type;
size_t size{};
details::readSize(reader, size, _maxSize, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
details::readSize(des.adapter(), size, _maxSize, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
obj.clear();
reserve(obj, size);
auto hint = obj.begin();

8
include/bitsery/ext/std_stack.h
View File

@@ -53,13 +53,13 @@ namespace bitsery {
public:
explicit StdStack(size_t maxSize):_maxSize{maxSize} {};
template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
void serialize(Ser &ser, Writer &, const std::stack<T,C> &obj, Fnc &&fnc) const {
template<typename Ser, typename T, typename C, typename Fnc>
void serialize(Ser &ser, const std::stack<T,C> &obj, Fnc &&fnc) const {
ser.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}
template<typename Des, typename Reader, typename T, typename C, typename Fnc>
void deserialize(Des &des, Reader &, std::stack<T,C> &obj, Fnc &&fnc) const {
template<typename Des, typename T, typename C, typename Fnc>
void deserialize(Des &des, std::stack<T,C> &obj, Fnc &&fnc) const {
des.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
}

8
include/bitsery/ext/std_tuple.h
View File

@@ -36,13 +36,13 @@ namespace bitsery {
class StdTuple : public details::CompositeTypeOverloadsUtils<std::tuple, Overloads...> {
public:
template<typename Ser, typename Writer, typename Fnc, typename ...Ts>
void serialize(Ser& ser, Writer&, const std::tuple<Ts...>& obj, Fnc&&) const {
template<typename Ser, typename Fnc, typename ...Ts>
void serialize(Ser& ser, const std::tuple<Ts...>& obj, Fnc&&) const {
serializeAll(ser, const_cast<std::tuple<Ts...>&>(obj));
}
template<typename Des, typename Reader, typename Fnc, typename ...Ts>
void deserialize(Des& des, Reader&, std::tuple<Ts...>& obj, Fnc&&) const {
template<typename Des, typename Fnc, typename ...Ts>
void deserialize(Des& des, std::tuple<Ts...>& obj, Fnc&&) const {
serializeAll(des, obj);
}

12
include/bitsery/ext/std_variant.h
View File

@@ -36,21 +36,21 @@ namespace bitsery {
class StdVariant : public details::CompositeTypeOverloadsUtils<std::variant, Overloads...> {
public:
template<typename Ser, typename Writer, typename Fnc, typename ...Ts>
void serialize(Ser& ser, Writer& writer, const std::variant<Ts...>& obj, Fnc&&) const {
template<typename Ser, typename Fnc, typename ...Ts>
void serialize(Ser& ser, const std::variant<Ts...>& obj, Fnc&&) const {
auto index = obj.index();
assert(index != std::variant_npos);
details::writeSize(writer, index);
details::writeSize(ser.adapter(), index);
this->execIndex(index, const_cast<std::variant<Ts...>&>(obj), [this, &ser](auto& data, auto index) {
constexpr size_t Index = decltype(index)::value;
this->serializeType(ser, std::get<Index>(data));
});
}
template<typename Des, typename Reader, typename Fnc, typename ...Ts>
void deserialize(Des& des, Reader& reader, std::variant<Ts...>& obj, Fnc&&) const {
template<typename Des, typename Fnc, typename ...Ts>
void deserialize(Des& des, std::variant<Ts...>& obj, Fnc&&) const {
size_t index{};
details::readSize(reader, index, sizeof...(Ts), std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
details::readSize(des.adapter(), index, sizeof...(Ts), std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
this->execIndex(index, obj, [this, &des](auto& data, auto index) {
constexpr size_t Index = decltype(index)::value;
using TElem = typename std::variant_alternative<Index, std::variant<Ts...>>::type;

61
include/bitsery/ext/utils/pointer_utils.h
View File

@@ -287,29 +287,29 @@ namespace bitsery {
_resource{resource} {
}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser& ser, Writer& w, const T& obj, Fnc&& fnc) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser& ser, const T& obj, Fnc&& fnc) const {
auto ptr = TPtrManager<T>::getPtr(const_cast<T&>(obj));
if (ptr) {
auto& ctx = ser.template context<pointer_utils::PointerLinkingContextSerialization>();
auto& ptrInfo = ctx.getInfoByPtr(getBasePtr(ptr), TPtrManager<T>::getOwnership());
details::writeSize(w, ptrInfo.id);
details::writeSize(ser.adapter(), ptrInfo.id);
if (TPtrManager<T>::getOwnership() != PointerOwnershipType::Observer) {
if (!ptrInfo.isSharedProcessed)
serializeImpl(ser, ptr, std::forward<Fnc>(fnc), w, IsPolymorphic<T>{});
serializeImpl(ser, ptr, std::forward<Fnc>(fnc), IsPolymorphic<T>{});
}
} else {
assert(_ptrType == PointerType::Nullable);
details::writeSize(w, 0);
details::writeSize(ser.adapter(), 0);
}
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des& des, Reader& r, T& obj, Fnc&& fnc) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des& des, T& obj, Fnc&& fnc) const {
size_t id{};
details::readSize(r, id, 0, std::false_type{});
details::readSize(des.adapter(), id, 0, std::false_type{});
auto& ctx = des.template context<pointer_utils::PointerLinkingContextDeserialization>();
auto prevResource = ctx.getMemResource();
auto memResource = _resource ? _resource : prevResource;
@@ -320,7 +320,7 @@ namespace bitsery {
}
if (id) {
auto& ptrInfo = ctx.getInfoById(id, TPtrManager<T>::getOwnership());
deserializeImpl(memResource, ptrInfo, des, obj, std::forward<Fnc>(fnc), r, IsPolymorphic<T>{},
deserializeImpl(memResource, ptrInfo, des, obj, std::forward<Fnc>(fnc), IsPolymorphic<T>{},
OwnershipType<TPtrManager<T>::getOwnership()>{});
} else {
if (_ptrType == PointerType::Nullable) {
@@ -328,7 +328,7 @@ namespace bitsery {
destroyPtr(memResource, des, obj, IsPolymorphic<T>{});
};
} else
r.error(ReaderError::InvalidPointer);
des.adapter().error(ReaderError::InvalidPointer);
}
if (_resource && _resourcePropagate) {
ctx.setMemResource(prevResource);
@@ -360,22 +360,22 @@ namespace bitsery {
return ptr;
}
template<typename Ser, typename TPtr, typename Fnc, typename Writer>
void serializeImpl(Ser& ser, TPtr& ptr, Fnc&&, Writer& w, std::true_type) const {
template<typename Ser, typename TPtr, typename Fnc>
void serializeImpl(Ser& ser, TPtr& ptr, Fnc&&, std::true_type) const {
const auto& ctx = ser.template context<TPolymorphicContext<RTTI>>();
ctx.serialize(ser, w, *ptr);
ctx.serialize(ser, *ptr);
}
template<typename Ser, typename TPtr, typename Fnc, typename Writer>
void serializeImpl(Ser& ser, TPtr& ptr, Fnc&& fnc, Writer&, std::false_type) const {
template<typename Ser, typename TPtr, typename Fnc>
void serializeImpl(Ser& ser, TPtr& ptr, Fnc&& fnc, std::false_type) const {
fnc(ser, *ptr);
}
template<typename Des, typename T, typename Fnc, typename Reader>
template<typename Des, typename T, typename Fnc>
void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
Reader& r, std::true_type, OwnershipType<PointerOwnershipType::Owner>) const {
std::true_type, OwnershipType<PointerOwnershipType::Owner>) const {
const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
ctx.deserialize(des, r, TPtrManager<T>::getPtr(obj),
ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
[&obj, this, memResource](
const std::shared_ptr<PolymorphicHandlerBase>& handler) {
TPtrManager<T>::createPolymorphic(obj, memResource, handler);
@@ -387,9 +387,9 @@ namespace bitsery {
ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
}
template<typename Des, typename T, typename Fnc, typename Reader>
template<typename Des, typename T, typename Fnc>
void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
Reader&, std::false_type, OwnershipType<PointerOwnershipType::Owner>) const {
std::false_type, OwnershipType<PointerOwnershipType::Owner>) const {
auto ptr = TPtrManager<T>::getPtr(obj);
if (ptr) {
fnc(des, *ptr);
@@ -401,13 +401,12 @@ namespace bitsery {
ptrInfo.processOwner(ptr);
}
template<typename Des, typename T, typename Fnc, typename Reader>
template<typename Des, typename T, typename Fnc>
void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
Reader& r, std::true_type,
OwnershipType<PointerOwnershipType::SharedOwner>) const {
std::true_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
if (!ptrInfo.sharedState) {
const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
ctx.deserialize(des, r, TPtrManager<T>::getPtr(obj),
ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
[&obj, &ptrInfo, memResource, this](
const std::shared_ptr<PolymorphicHandlerBase>& handler) {
TPtrManager<T>::createSharedPolymorphic(
@@ -425,9 +424,9 @@ namespace bitsery {
ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
}
template<typename Des, typename T, typename Fnc, typename Reader>
template<typename Des, typename T, typename Fnc>
void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
Reader&, std::false_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
std::false_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
if (!ptrInfo.sharedState) {
auto ptr = TPtrManager<T>::getPtr(obj);
if (ptr) {
@@ -444,17 +443,17 @@ namespace bitsery {
ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
}
template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorph>
template<typename Des, typename T, typename Fnc, typename isPolymorph>
void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj,
Fnc&& fnc, Reader& r, isPolymorph polymorph,
Fnc&& fnc, isPolymorph polymorph,
OwnershipType<PointerOwnershipType::SharedObserver>) const {
deserializeImpl(memResource, ptrInfo, des, obj, fnc, r, polymorph,
deserializeImpl(memResource, ptrInfo, des, obj, fnc, polymorph,
OwnershipType<PointerOwnershipType::SharedOwner>{});
}
template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorphic>
template<typename Des, typename T, typename Fnc, typename isPolymorphic>
void deserializeImpl(MemResourceBase* , PLCInfoDeserializer& ptrInfo, Des&, T& obj, Fnc&&,
Reader&, isPolymorphic, OwnershipType<PointerOwnershipType::Observer>) const {
isPolymorphic, OwnershipType<PointerOwnershipType::Observer>) const {
ptrInfo.processObserver(reinterpret_cast<void*&>(TPtrManager<T>::getPtrRef(obj)));
}

14
include/bitsery/ext/utils/polymorphism_utils.h
View File

@@ -226,8 +226,8 @@ namespace bitsery {
}
template<typename Serializer, typename Writer, typename TBase>
void serialize(Serializer& ser, Writer& writer, TBase& obj) const {
template<typename Serializer, typename TBase>
void serialize(Serializer& ser, TBase& obj) const {
//get derived key
BaseToDerivedKey key{RTTI::template get<TBase>(), RTTI::template get<TBase>(obj)};
auto it = _baseToDerivedMap.find(key);
@@ -237,17 +237,17 @@ namespace bitsery {
auto& vec = _baseToDerivedArray.find(key.baseHash)->second;
auto derivedIndex = static_cast<size_t>(std::distance(vec.begin(), std::find(vec.begin(), vec.end(),
key.derivedHash)));
details::writeSize(writer, derivedIndex);
details::writeSize(ser.adapter(), derivedIndex);
//serialize
it->second->process(&ser, &obj);
}
template<typename Deserializer, typename Reader, typename TBase, typename TCreateFnc, typename TDestroyFnc>
void deserialize(Deserializer& des, Reader& reader, TBase* obj,
template<typename Deserializer, typename TBase, typename TCreateFnc, typename TDestroyFnc>
void deserialize(Deserializer& des, TBase* obj,
TCreateFnc createFnc, TDestroyFnc destroyFnc) const {
size_t derivedIndex{};
details::readSize(reader, derivedIndex, 0, std::false_type{});
details::readSize(des.adapter(), derivedIndex, 0, std::false_type{});
auto baseToDerivedVecIt = _baseToDerivedArray.find(RTTI::template get<TBase>());
//base class is known at compile time, so we can assert on this one
@@ -267,7 +267,7 @@ namespace bitsery {
}
handler->process(&des, obj);
} else
reader.error(ReaderError::InvalidPointer);
des.adapter().error(ReaderError::InvalidPointer);
}
template<typename TBase>

13
include/bitsery/ext/value_range.h
View File

@@ -167,18 +167,19 @@ namespace bitsery {
constexpr ValueRange(const TValue& min, const TValue& max, Args &&... args)
:_range{min, max, std::forward<Args>(args)...} {}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &, Writer &writer, const T &v, Fnc &&) const {
template<typename Ser, typename T, typename Fnc>
void serialize(Ser &ser, const T &v, Fnc &&) const {
assert(details::isRangeValid(v, _range));
using BT = decltype(details::getRangeValue(v, _range));
writer.template writeBits<BT>(details::getRangeValue(v, _range), _range.bitsRequired);
ser.adapter().template writeBits<BT>(details::getRangeValue(v, _range), _range.bitsRequired);
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &, Reader &reader, T &v, Fnc &&) const {
template<typename Des, typename T, typename Fnc>
void deserialize(Des &des, T &v, Fnc &&) const {
auto& reader = des.adapter();
reader.readBits(reinterpret_cast<details::SameSizeUnsigned<T> &>(v), _range.bitsRequired);
details::setRangeValue(v, _range);
handleInvalidRange(reader, v, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
handleInvalidRange(reader, v, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
}
constexpr size_t getRequiredBits() const {

7
include/bitsery/serializer.h
View File

@@ -166,6 +166,7 @@ namespace bitsery {
using BPEnabledType = BasicSerializer<typename std::conditional<TOutputAdapter::BitPackingEnabled,
TOutputAdapter,
details::OutputAdapterBitPackingWrapper<TOutputAdapter>>::type, TContext>;
using TConfig = typename TOutputAdapter::TConfig;
using details::AdapterAndContextRef<TOutputAdapter, TContext>::AdapterAndContextRef;
@@ -230,7 +231,7 @@ namespace bitsery {
static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
"extension doesn't support overload with lambda");
extension.serialize(*this, this->_adapter, obj, std::forward<Fnc>(fnc));
extension.serialize(*this, obj, std::forward<Fnc>(fnc));
}
template<size_t VSIZE, typename T, typename Ext>
@@ -240,7 +241,7 @@ namespace bitsery {
"extension doesn't support overload with `value<N>`");
using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
extension.serialize(*this, this->_adapter, obj, [](BasicSerializer& s, VType &v) { s.value<VSIZE>(v); });
extension.serialize(*this, obj, [](BasicSerializer& s, VType &v) { s.value<VSIZE>(v); });
}
template<typename T, typename Ext>
@@ -250,7 +251,7 @@ namespace bitsery {
"extension doesn't support overload with `object`");
using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
extension.serialize(*this, this->_adapter, obj, [](BasicSerializer& s, VType &v) { s.object(v); });
extension.serialize(*this, obj, [](BasicSerializer& s, VType &v) { s.object(v); });
}
/*