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

maxSize archive modifying function now works with extensions

Browse Source
This commit is contained in:
fraillt
2017-10-13 09:33:56 +03:00
parent f3c9a33849
commit 4ccd4d368e
18 changed files with 365 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -41,11 +41,12 @@ namespace bitsery {
:_ios{istream} {}
void read(TValue* data, size_t size) {
_ios.rdbuf()->sgetn( data , size );
if (static_cast<size_t>(_ios.rdbuf()->sgetn( data , size )) != size)
*data = {};
}
ReaderError error() const {
if (!_ios.bad())
if (_ios.good())
return ReaderError::NoError;
return _ios.eof()
? ReaderError::DataOverflow

5
include/bitsery/adapter_reader.h
View File

@@ -56,9 +56,10 @@ namespace bitsery {
AdapterReader &operator=(const AdapterReader &) = delete;
AdapterReader(AdapterReader &&) noexcept = default;
//todo add conditional noexcept
AdapterReader(AdapterReader &&) = default;
AdapterReader &operator=(AdapterReader &&) noexcept = default;
AdapterReader &operator=(AdapterReader &&) = default;
~AdapterReader() noexcept = default;

5
include/bitsery/adapter_writer.h
View File

@@ -117,9 +117,10 @@ namespace bitsery {
AdapterWriter &operator=(const AdapterWriter &) = delete;
AdapterWriter(AdapterWriter &&) noexcept = default;
//todo add conditional noexcept
AdapterWriter(AdapterWriter &&) = default;
AdapterWriter &operator=(AdapterWriter &&) noexcept = default;
AdapterWriter &operator=(AdapterWriter &&) = default;
~AdapterWriter() {
flush();

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

@@ -113,9 +113,34 @@ namespace bitsery {
size_t maxSize;
};
//if container, then call procesContainer, this memcpy for fundamental types contiguous container
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) {
processContainer(s, ms.data, ms.maxSize);
processMaxSize(s, ms.data, ms.maxSize, details::IsContainerTraitsDefined<typename std::decay<T>::type>{});
};
}

1
include/bitsery/flexible.h
View File

@@ -69,7 +69,6 @@ namespace bitsery {
return {obj, max};
}
//define serialize function for fundamental types
template<typename S>
void serialize(S &s, bool &v) {

8
include/bitsery/flexible/map.h
View File

@@ -29,10 +29,10 @@
namespace bitsery {
template<typename S, typename ... TArgs>
void serialize(S &s, std::map<TArgs ... > &obj) {
void serialize(S &s, std::map<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
using TKey = typename std::map<TArgs...>::key_type;
using TValue = typename std::map<TArgs...>::mapped_type;
s.ext(obj, ext::StdMap{std::numeric_limits<size_t>::max()},
s.ext(obj, ext::StdMap{maxSize},
[&s](TKey& key, TValue& value) {
s.object(key);
s.object(value);
@@ -40,10 +40,10 @@ namespace bitsery {
}
template<typename S, typename ... TArgs>
void serialize(S &s, std::multimap<TArgs ... > &obj) {
void serialize(S &s, std::multimap<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
using TKey = typename std::multimap<TArgs...>::key_type;
using TValue = typename std::multimap<TArgs...>::mapped_type;
s.ext(obj, ext::StdMap{std::numeric_limits<size_t>::max()},
s.ext(obj, ext::StdMap{maxSize},
[&s](TKey& key, TValue& value) {
s.object(key);
s.object(value);

8
include/bitsery/flexible/queue.h
View File

@@ -28,13 +28,13 @@
namespace bitsery {
template<typename S, typename T, typename C>
void serialize(S &s, std::queue<T, C> &obj) {
s.ext(obj, ext::StdQueue{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::queue<T, C> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdQueue{maxSize});
}
template<typename S, typename T, typename C, typename Comp>
void serialize(S &s, std::priority_queue<T, C, Comp> &obj) {
s.ext(obj, ext::StdQueue{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::priority_queue<T, C, Comp> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdQueue{maxSize});
}
}

8
include/bitsery/flexible/set.h
View File

@@ -29,13 +29,13 @@
namespace bitsery {
template<typename S, typename ... TArgs>
void serialize(S &s, std::set<TArgs...> &obj) {
s.ext(obj, ext::StdSet{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::set<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdSet{maxSize});
}
template<typename S, typename ... TArgs>
void serialize(S &s, std::multiset<TArgs...> &obj) {
s.ext(obj, ext::StdSet{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::multiset<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdSet{maxSize});
}
}

4
include/bitsery/flexible/stack.h
View File

@@ -28,8 +28,8 @@
namespace bitsery {
template<typename S, typename T, typename C>
void serialize(S &s, std::stack<T, C> &obj) {
s.ext(obj, ext::StdStack{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::stack<T, C> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdStack{maxSize});
}
}

8
include/bitsery/flexible/unordered_map.h
View File

@@ -29,10 +29,10 @@
namespace bitsery {
template<typename S, typename ... TArgs>
void serialize(S &s, std::unordered_map<TArgs ... > &obj) {
void serialize(S &s, std::unordered_map<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
using TKey = typename std::unordered_map<TArgs...>::key_type;
using TValue = typename std::unordered_map<TArgs...>::mapped_type;
s.ext(obj, ext::StdMap{std::numeric_limits<size_t>::max()},
s.ext(obj, ext::StdMap{maxSize},
[&s](TKey& key, TValue& value) {
s.object(key);
s.object(value);
@@ -40,10 +40,10 @@ namespace bitsery {
}
template<typename S, typename ... TArgs>
void serialize(S &s, std::unordered_multimap<TArgs ... > &obj) {
void serialize(S &s, std::unordered_multimap<TArgs ... > &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
using TKey = typename std::unordered_multimap<TArgs...>::key_type;
using TValue = typename std::unordered_multimap<TArgs...>::mapped_type;
s.ext(obj, ext::StdMap{std::numeric_limits<size_t>::max()},
s.ext(obj, ext::StdMap{maxSize},
[&s](TKey& key, TValue& value) {
s.object(key);
s.object(value);

8
include/bitsery/flexible/unordered_set.h
View File

@@ -29,13 +29,13 @@
namespace bitsery {
template<typename S, typename ... TArgs>
void serialize(S &s, std::unordered_set<TArgs...> &obj) {
s.ext(obj, ext::StdSet{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::unordered_set<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdSet{maxSize});
}
template<typename S, typename ... TArgs>
void serialize(S &s, std::unordered_multiset<TArgs...> &obj) {
s.ext(obj, ext::StdSet{std::numeric_limits<size_t>::max()});
void serialize(S &s, std::unordered_multiset<TArgs...> &obj, size_t maxSize = std::numeric_limits<size_t>::max()) {
s.ext(obj, ext::StdSet{maxSize});
}
}