Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-10-06 17:05:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

compile warnings, and usage improvements for VisualStudio

Browse Source
This commit is contained in:
fraillt
2017-10-16 12:45:28 +03:00
parent 1acb9af188
commit bdc24eb3c2
41 changed files with 339 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -135,8 +135,8 @@ namespace bitsery {
using TResizable = std::integral_constant<bool, traits::ContainerTraits<Container>::isResizable>;
Container &_buffer;
TIterator _outIt;
TIterator _end;
TIterator _outIt{};
TIterator _end{};
/*
* resizable buffer
@@ -153,12 +153,23 @@ namespace bitsery {
void writeInternal(const TValue *data, const size_t size, std::true_type) {
//optimization
#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
using TDistance = typename std::iterator_traits<TIterator>::difference_type;
if (std::distance(_outIt , _end) >= static_cast<TDistance>(size)) {
std::memcpy(std::addressof(*_outIt), data, size);
_outIt += size;
#else
auto tmp = _outIt;
_outIt += size;
if (std::distance(_outIt , _end) >= 0) {
std::memcpy(std::addressof(*tmp), data, size);
#endif
} else {
#if defined(_MSC_VER) && (_ITERATOR_DEBUG_LEVEL > 0)
#else
_outIt -= size;
#endif
//get current position before invalidating iterators
const auto pos = std::distance(std::begin(_buffer), _outIt);
//increase container size

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

@@ -41,8 +41,13 @@ namespace bitsery {
:_ios{istream} {}
void read(TValue* data, size_t size) {
if (static_cast<size_t>(_ios.rdbuf()->sgetn( data , size )) != size)
if (static_cast<size_t>(_ios.rdbuf()->sgetn( data , size )) != size) {
*data = {};
//check state, if not set by stream, set it manually
if (_ios.good())
_ios.setstate(std::ios_base::eofbit);
}
}
ReaderError error() const {
@@ -58,7 +63,7 @@ namespace bitsery {
}
return false;
}
void setError(ReaderError error) {
void setError(ReaderError ) {
//has no effect when using
}

5
include/bitsery/adapter_reader.h
View File

@@ -142,14 +142,15 @@ namespace bitsery {
}
template<typename T>
void _swapDataBits(T *v, size_t count, std::false_type) {
void _swapDataBits(T *, size_t , std::false_type) {
//empty function because no swap is required
}
};
template<typename TReader>
struct AdapterReaderBitPackingWrapper {
class AdapterReaderBitPackingWrapper {
public:
//this is required by deserializer
static constexpr bool BitPackingEnabled = true;
//make TValue unsigned for bitpacking

2
include/bitsery/bitsery.h
View File

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

28
include/bitsery/deserializer.h
View File

@@ -46,7 +46,7 @@ namespace bitsery {
: _reader{std::forward<ReaderParam>(r)},
_context{context}
{
};
}
//copying disabled
BasicDeserializer(const BasicDeserializer&) = delete;
@@ -76,7 +76,7 @@ namespace bitsery {
template<typename T, typename Fnc>
void object(T &&obj, Fnc &&fnc) {
fnc(std::forward<T>(obj));
};
}
/*
* functionality, that enables simpler serialization syntax, by including additional header
@@ -117,7 +117,7 @@ namespace bitsery {
static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
"extension doesn't support overload with lambda");
extension.deserialize(*this, _reader, obj, std::forward<Fnc>(fnc));
};
}
template<size_t VSIZE, typename T, typename Ext>
void ext(T &obj, const Ext &extension) {
@@ -127,7 +127,7 @@ namespace bitsery {
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, _reader, obj, [this](VType &v) { value<VSIZE>(v);});
};
}
template<typename T, typename Ext>
void ext(T &obj, const Ext &extension) {
@@ -137,7 +137,7 @@ namespace bitsery {
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, _reader, obj, [this](VType &v) { object(v); });
};
}
/*
* boolValue
@@ -263,16 +263,16 @@ namespace bitsery {
void value8b(T &&v) { value<8>(std::forward<T>(v)); }
template<typename T, typename Ext>
void ext1b(T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); };
void ext1b(T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext2b(T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); };
void ext2b(T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext4b(T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); };
void ext4b(T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext8b(T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); };
void ext8b(T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T>
void text1b(T &str, size_t maxSize) { text<1>(str, maxSize); }
@@ -328,7 +328,7 @@ namespace bitsery {
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
@@ -338,21 +338,21 @@ namespace bitsery {
using TIntegral = typename details::IntegralFromFundamental<TValue>::TValue;
if (first != last)
_reader.template readBuffer<VSIZE>(reinterpret_cast<TIntegral*>(&(*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(*first);
};
}
//process object types
template<typename It>
void procContainer(It first, It last) {
for (; first != last; ++first)
object(*first);
};
}
template <size_t VSIZE, typename T>
void procText(T& str, size_t length) {
@@ -421,7 +421,7 @@ namespace bitsery {
des.object(value);
auto& r = AdapterAccess::getReader(des);
return {r.error(), r.isCompletedSuccessfully()};
};
}
}

10
include/bitsery/details/flexible_common.h
View File

@@ -117,31 +117,31 @@ namespace bitsery {
template<typename S, typename T>
void processMaxSize(S &s, T& data, size_t maxSize, std::true_type) {
processContainer(s, data, maxSize);
};
}
//overload for const T&
template<typename S, typename T>
void processMaxSize(S &s, const T& data, size_t maxSize, std::true_type) {
processContainer(s, const_cast<T&>(data), maxSize);
};
}
//try to call serialize overload with maxsize, extensions use this technique
template<typename S, typename T>
void processMaxSize(S &s, T& data, size_t maxSize, std::false_type) {
serialize(s, data, maxSize);
};
}
//overload for const T&
template<typename S, typename T>
void processMaxSize(S &s, const T& data, size_t maxSize, std::false_type) {
serialize(s, const_cast<T&>(data), maxSize);
};
}
template<typename S, typename T>
void serialize(S &s, const MaxSize<T> &ms) {
processMaxSize(s, ms.data, ms.maxSize, details::IsContainerTraitsDefined<typename std::decay<T>::type>{});
};
}
}
}

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

@@ -32,7 +32,7 @@ namespace bitsery {
struct NotDefinedType {
//just swallow anything that is passed during creating
template <typename ... T>
NotDefinedType(T&& ...){};
NotDefinedType(T&& ...){}
NotDefinedType() = default;
//define operators so that we also swallow deeper errors, to reduce error stack
//this time will be used as iterator, so define all operators nessesarry to work with iterators

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

@@ -70,38 +70,88 @@ namespace bitsery {
struct IsExtensionTraitsDefined:public IsDefined<typename traits::ExtensionTraits<Ext, T>::TValue> {
};
//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;
#ifdef _MSC_VER
//helper types for HasSerializeFunction
template <typename S, typename T>
using TrySerializeFunction = decltype(serialize(std::declval<S &>(), std::declval<T &>()));
template <typename, typename, typename = void>
struct HasSerializeFunction:std::false_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 {};
template <typename S, typename T>
struct HasSerializeFunction<S,T,
void_t<decltype(serialize(std::declval<S &>(), std::declval<T &>()))>
> : std::true_type {};
//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 {};
//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 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;
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, 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 {};
//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 {};
#endif
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, 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 {};
//used for extensions, when extension TValue = void
struct DummyType {
@@ -177,10 +227,8 @@ namespace bitsery {
struct ArchiveFunction {
static void invoke(S &s, T&& obj) {
static_assert(IsFlexibleIncluded<S,T>::value,
static_assert(IsFlexibleIncluded<S, T>::value,
"\nPlease include '<bitsery/flexible.h>' to use 'archive' function:\n");
// static_assert(HasSerializeFunction<S,T>::value || HasSerializeMethod<S,T>::value,
// "\nPlease define 'serialize' function or include '<bitsery/flexible/...>' to use with 'archive'\n");
archiveProcess(s, std::forward<T>(obj));
}

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

@@ -54,6 +54,13 @@ namespace bitsery {
class SessionsWriter {
public:
SessionsWriter() = default;
SessionsWriter(const SessionsWriter&) = delete;
SessionsWriter& operator = (const SessionsWriter& ) = delete;
SessionsWriter(SessionsWriter&&) = default;
SessionsWriter& operator = (SessionsWriter&& ) = default;
void begin(TWriter& ) {
//write position
_sessionIndex.push(_sessions.size());
@@ -65,7 +72,9 @@ namespace bitsery {
//change position to session end
auto sessionIt = std::next(std::begin(_sessions), _sessionIndex.top());
_sessionIndex.pop();
*sessionIt = writer.writtenBytesCount();
auto sessionSize = writer.writtenBytesCount();
assert(sessionSize > 0);
*sessionIt = sessionSize;
}
void flushSessions(TWriter& writer) {
@@ -85,7 +94,7 @@ namespace bitsery {
}
private:
std::vector<size_t> _sessions{};
std::stack<size_t> _sessionIndex;
std::stack<size_t> _sessionIndex{};
};
template <typename TReader>
@@ -100,6 +109,13 @@ namespace bitsery {
_endItRef{details::SessionAccess::endIteratorRef<InputAdapter, TIterator>(adapter)}
{
}
SessionsReader(const SessionsReader&) = delete;
SessionsReader& operator = (const SessionsReader& ) = delete;
SessionsReader(SessionsReader&&) = default;
SessionsReader& operator = (SessionsReader&& ) = default;
void begin() {
if (_sessions.empty()) {
if (!initializeSessions())
@@ -125,7 +141,7 @@ namespace bitsery {
} else {
//there is no data to read anymore
//pos == end or buffer overflow while session is active
if (!(_posItRef == _endItRef || _reader.error() == ReaderError::NoError)) {
if (!(_posItRef == _endItRef || _reader.error() == ReaderError::NoError) || !(_sessionsStack.size() > 1)) {
_reader.setError(ReaderError::InvalidData);
}
}

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

@@ -37,7 +37,7 @@ namespace bitsery {
++index;
}
return 0u;
};
}
}
namespace ext {
@@ -57,7 +57,7 @@ namespace bitsery {
};
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &s, Writer &writer, const T &obj, Fnc &&fnc) const {
void serialize(Ser &s, Writer &, 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)});
@@ -68,7 +68,7 @@ namespace bitsery {
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &d, Reader &reader, T &obj, Fnc &&fnc) const {
void deserialize(Des &d, Reader &, 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)});

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

@@ -34,14 +34,14 @@ namespace bitsery {
public:
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &s, Writer &writer, const T &obj, Fnc &&fnc) const {
void serialize(Ser &, Writer &writer, const T &obj, Fnc &&fnc) const {
writer.beginSession();
fnc(const_cast<T&>(obj));
writer.endSession();
}
template<typename Des, typename Reader, typename T, typename Fnc>
void deserialize(Des &d, Reader &reader, T &obj, Fnc &&fnc) const {
void deserialize(Des &, Reader &reader, T &obj, Fnc &&fnc) const {
reader.beginSession();
fnc(obj);
reader.endSession();

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

@@ -74,7 +74,7 @@ namespace bitsery {
obj.reserve(size);
}
template <typename T>
void reserve(T obj, size_t size) const {
void reserve(T& , size_t ) const {
//for ordered container do nothing
}
size_t _maxSize;

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

@@ -108,13 +108,13 @@ namespace bitsery {
template<typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
return static_cast<details::SameSizeUnsigned<T>>(v - r.min);
};
}
template<typename T, typename std::enable_if<std::is_enum<T>::value>::type * = nullptr>
details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
using VT = details::SameSizeUnsigned<T>;
return static_cast<VT>(static_cast<VT>(v) - static_cast<VT>(r.min));
};
}
template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
details::SameSizeUnsigned<T> getRangeValue(const T &v, const RangeSpec<T> &r) {
@@ -122,18 +122,18 @@ namespace bitsery {
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 = typename std::underlying_type<T>::type;
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) {
@@ -141,7 +141,7 @@ namespace bitsery {
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) {
@@ -163,7 +163,7 @@ namespace bitsery {
public:
template<typename ... Args>
explicit constexpr ValueRange(Args &&... args):_range{std::forward<Args>(args)...} {};
explicit constexpr ValueRange(Args &&... args):_range{std::forward<Args>(args)...} {}
template<typename Ser, typename Writer, typename T, typename Fnc>
void serialize(Ser &, Writer &writer, const T &v, Fnc &&) const {

18
include/bitsery/flexible.h
View File

@@ -35,7 +35,7 @@ namespace bitsery {
template<typename S, typename T>
void archiveProcessImpl(S &s, T &&head, std::true_type) {
s.object(std::forward<T>(head));
};
}
//overload when T is rvalue type, only allowable for behaviour modifying functions for deserializer
template<typename S, typename T>
@@ -43,7 +43,7 @@ namespace bitsery {
static_assert(std::is_base_of<ArchiveWrapperFnc, T>::value,
"\nOnly archive behaviour modifying functions can be passed by rvalue to deserializer\n");
serialize(s, head);
};
}
}
@@ -57,12 +57,12 @@ namespace bitsery {
template<typename T, size_t N>
flexible::CArray<T, N, true> asText(T (&str)[N]) {
return {str};
};
}
template<typename T, size_t N>
flexible::CArray<T, N, false> asContainer(T (&obj)[N]) {
return {obj};
};
}
template <typename T>
flexible::MaxSize<T> maxSize(T& obj, size_t max) {
@@ -78,21 +78,21 @@ namespace bitsery {
template<typename S, typename T, typename std::enable_if<details::IsFundamentalType<T>::value>::type * = nullptr>
void serialize(S &s, T &v) {
s.template value<sizeof(T)>(v);
};
}
//define serialization for c-style container
//if array is integral type, specify explicitly how to process: as text or container
template<typename S, typename T, size_t N, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
void serialize(S &s, T (&obj)[N]) {
void serialize(S &, T (&)[N]) {
static_assert(N == 0,
"\nPlease use 'asText(obj)' or 'asContainer(obj)' when using c-style array with integral types\n");
};
}
template<typename S, typename T, size_t N, typename std::enable_if<!std::is_integral<T>::value>::type * = nullptr>
void serialize(S &s, T (&obj)[N]) {
flexible::processContainer(s, obj);
};
}
//this is a helper class that enforce fundamental type sizes, when used on multiple platforms
template <size_t TShort, size_t TInt, size_t TLong, size_t TLongLong>
@@ -103,7 +103,7 @@ namespace bitsery {
static_assert(sizeof(long) == TLong, "");
static_assert(sizeof(long long) == TLongLong, "");
//for completion we also need pointer type size, but serializer doesn't support pointer serialization.
};
}
}

30
include/bitsery/serializer.h
View File

@@ -44,7 +44,7 @@ namespace bitsery {
: _writer{std::forward<WriterParam>(w)},
_context{context}
{
};
}
//copying disabled
BasicSerializer(const BasicSerializer&) = delete;
@@ -73,7 +73,7 @@ namespace bitsery {
template<typename T, typename Fnc>
void object(const T &obj, Fnc &&fnc) {
fnc(const_cast<T& >(obj));
};
}
/*
* functionality, that enables simpler serialization syntax, by including additional header
@@ -114,7 +114,7 @@ namespace bitsery {
static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
"extension doesn't support overload with lambda");
extension.serialize(*this, _writer, obj, std::forward<Fnc>(fnc));
};
}
template<size_t VSIZE, typename T, typename Ext>
void ext(const T &obj, const Ext &extension) {
@@ -124,7 +124,7 @@ namespace bitsery {
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, _writer, obj, [this](VType &v) { value<VSIZE>(v); });
};
}
template<typename T, typename Ext>
void ext(const T &obj, const Ext &extension) {
@@ -134,7 +134,7 @@ namespace bitsery {
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, _writer, obj, [this](VType &v) { object(v); });
};
}
/*
* boolValue
@@ -259,16 +259,16 @@ namespace bitsery {
void value8b(T &&v) { value<8>(std::forward<T>(v)); }
template<typename T, typename Ext>
void ext1b(const T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); };
void ext1b(const T &v, Ext &&extension) { ext<1, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext2b(const T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); };
void ext2b(const T &v, Ext &&extension) { ext<2, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext4b(const T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); };
void ext4b(const T &v, Ext &&extension) { ext<4, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T, typename Ext>
void ext8b(const T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); };
void ext8b(const T &v, Ext &&extension) { ext<8, T, Ext>(v, std::forward<Ext>(extension)); }
template<typename T>
void text1b(const T &str, size_t maxSize) { text<1>(str, maxSize); }
@@ -324,7 +324,7 @@ namespace bitsery {
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
@@ -335,7 +335,7 @@ namespace bitsery {
if (first != last)
_writer.template writeBuffer<VSIZE>(reinterpret_cast<const TIntegral*>(&(*first)),
static_cast<size_t>(std::distance(first, last)));
};
}
//process by calling functions
template<typename It, typename Fnc>
@@ -344,7 +344,7 @@ namespace bitsery {
for (; first != last; ++first) {
fnc(const_cast<TValue&>(*first));
}
};
}
//process text,
template<size_t VSIZE, typename T>
@@ -354,14 +354,14 @@ namespace bitsery {
details::writeSize(_writer, length);
auto begin = std::begin(str);
procContainer<VSIZE>(begin, std::next(begin, length), std::integral_constant<bool, traits::ContainerTraits<T>::isContiguous>{});
};
}
//process object types
template<typename It>
void procContainer(It first, It last) {
for (; first != last; ++first)
object(*first);
};
}
//proc bool writing bit or byte, depending on if BitPackingEnabled or not
void procBoolValue(bool v, std::true_type) {
@@ -413,7 +413,7 @@ namespace bitsery {
auto& w = AdapterAccess::getWriter(ser);
w.flush();
return w.writtenBytesCount();
};
}
template <typename T>
size_t quickMeasureSize(const T& value) {

10
include/bitsery/traits/core/traits.h
View File

@@ -62,12 +62,12 @@ namespace bitsery {
//contiguous hopefully will be available in c++20
static constexpr bool isContiguous = false;
//resize function, called only if container is resizable
static void resize(T& container, size_t size) {
static void resize(T& , size_t ) {
static_assert(std::is_void<T>::value,
"Define ContainerTraits or include from <bitsery/traits/...> to use as container");
}
//get container size
static size_t size(const T& container) {
static size_t size(const T& ) {
static_assert(std::is_void<T>::value,
"Define ContainerTraits or include from <bitsery/traits/...> to use as container");
return 0u;
@@ -80,7 +80,7 @@ namespace bitsery {
using TValue = T;
static constexpr bool isResizable = false;
static constexpr bool isContiguous = true;
static size_t size(const T (&container)[N]) {
static size_t size(const T (&)[N]) {
return N;
}
};
@@ -106,7 +106,7 @@ namespace bitsery {
static constexpr bool addNUL = true;
//get length of null terminated container
static size_t length(const T& container) {
static size_t length(const T& ) {
static_assert(std::is_void<T>::value,
"Define TextTraits or include from <bitsery/traits/...> to use as text");
return 0u;
@@ -124,7 +124,7 @@ namespace bitsery {
//instead of using back_insert_iterator to append each byte to buffer.
//thats why Writer return range iterators
static void increaseBufferSize(T& container) {
static void increaseBufferSize(T& ) {
static_assert(std::is_void<T>::value,
"Define BufferAdapterTraits or include from <bitsery/traits/...> to use as buffer adapter container");
}