mirror of
https://github.com/fraillt/bitsery.git
synced 2026-09-22 18:24:35 +00:00
format code base in Mozilla style
This commit is contained in:
Mindaugas Vinkelis
@@ -1,351 +1,394 @@
|
||||
//MIT License
|
||||
// MIT License
|
||||
//
|
||||
//Copyright (c) 2019 Mindaugas Vinkelis
|
||||
// Copyright (c) 2019 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:
|
||||
// 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 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.
|
||||
// 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.
|
||||
|
||||
#include <forward_list>
|
||||
#include <bitsery/traits/forward_list.h>
|
||||
#include <bitsery/ext/std_set.h>
|
||||
#include <bitsery/ext/std_map.h>
|
||||
#include <bitsery/ext/pointer.h>
|
||||
#include <bitsery/ext/std_map.h>
|
||||
#include <bitsery/ext/std_set.h>
|
||||
#include <bitsery/ext/std_smart_ptr.h>
|
||||
#include <bitsery/traits/forward_list.h>
|
||||
#include <forward_list>
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "serialization_test_utils.h"
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
|
||||
using testing::ContainerEq;
|
||||
using testing::Eq;
|
||||
|
||||
//forward declare, for testing with std::unordered_map
|
||||
// forward declare, for testing with std::unordered_map
|
||||
class HasherForNonDefaultConstructible;
|
||||
|
||||
class NonDefaultConstructible {
|
||||
int32_t i{0};
|
||||
friend class HasherForNonDefaultConstructible;
|
||||
class NonDefaultConstructible
|
||||
{
|
||||
int32_t i{ 0 };
|
||||
friend class HasherForNonDefaultConstructible;
|
||||
|
||||
friend class bitsery::Access;
|
||||
NonDefaultConstructible() = default;
|
||||
|
||||
|
||||
|
||||
friend class bitsery::Access;
|
||||
NonDefaultConstructible() = default;
|
||||
|
||||
template <typename S>
|
||||
void serialize(S& s) {
|
||||
s.value4b(i);
|
||||
}
|
||||
template<typename S>
|
||||
void serialize(S& s)
|
||||
{
|
||||
s.value4b(i);
|
||||
}
|
||||
|
||||
public:
|
||||
explicit NonDefaultConstructible(int32_t v)
|
||||
: i{ v }
|
||||
{
|
||||
}
|
||||
|
||||
explicit NonDefaultConstructible(int32_t v):i{v} {}
|
||||
bool operator==(const NonDefaultConstructible& other) const
|
||||
{
|
||||
return i == other.i;
|
||||
}
|
||||
|
||||
bool operator == (const NonDefaultConstructible& other) const {
|
||||
return i == other.i;
|
||||
}
|
||||
|
||||
bool operator < (const NonDefaultConstructible& other) const {
|
||||
return i < other.i;
|
||||
}
|
||||
bool operator<(const NonDefaultConstructible& other) const
|
||||
{
|
||||
return i < other.i;
|
||||
}
|
||||
};
|
||||
|
||||
class HasherForNonDefaultConstructible {
|
||||
class HasherForNonDefaultConstructible
|
||||
{
|
||||
public:
|
||||
size_t operator()(const NonDefaultConstructible& o) const {
|
||||
return std::hash<int32_t>()(o.i);
|
||||
}
|
||||
size_t operator()(const NonDefaultConstructible& o) const
|
||||
{
|
||||
return std::hash<int32_t>()(o.i);
|
||||
}
|
||||
};
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, Container)
|
||||
{
|
||||
SerializationContext ctx{};
|
||||
std::vector<NonDefaultConstructible> data{};
|
||||
data.emplace_back(1);
|
||||
data.emplace_back(2);
|
||||
data.emplace_back(3);
|
||||
std::vector<NonDefaultConstructible> res{};
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
// this test is here, because when object is not constructible we cannot simple
|
||||
// "resize" container
|
||||
TEST(DeserializeNonDefaultConstructible, ResultContainerShouldShrink)
|
||||
{
|
||||
SerializationContext ctx{};
|
||||
std::vector<NonDefaultConstructible> data{};
|
||||
data.emplace_back(1);
|
||||
std::vector<NonDefaultConstructible> res{};
|
||||
res.emplace_back(2);
|
||||
res.emplace_back(3);
|
||||
res.emplace_back(4);
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, Container) {
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, ResultStdForwardListShouldShrink)
|
||||
{
|
||||
// forward list doesn't have .erase function, bet has erase_after
|
||||
// in this case, if new size is 0 it must call clear, so we need to check two
|
||||
// cases
|
||||
{
|
||||
// 1) when result should have more than 0 elements
|
||||
SerializationContext ctx{};
|
||||
std::vector<NonDefaultConstructible> data{};
|
||||
data.emplace_back(1);
|
||||
data.emplace_back(2);
|
||||
data.emplace_back(3);
|
||||
std::vector<NonDefaultConstructible> res{};
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
data.push_front(NonDefaultConstructible{ 1 });
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
res.push_front(NonDefaultConstructible{ 21 });
|
||||
res.push_front(NonDefaultConstructible{ 14 });
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
//this test is here, because when object is not constructible we cannot simple "resize" container
|
||||
TEST(DeserializeNonDefaultConstructible, ResultContainerShouldShrink) {
|
||||
auto resIt = res.begin();
|
||||
for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
|
||||
EXPECT_THAT(*resIt, Eq(*it));
|
||||
}
|
||||
EXPECT_THAT(resIt, Eq(res.end()));
|
||||
}
|
||||
{
|
||||
// 1) when result should have 0 elements
|
||||
SerializationContext ctx{};
|
||||
std::vector<NonDefaultConstructible> data{};
|
||||
data.emplace_back(1);
|
||||
std::vector<NonDefaultConstructible> res{};
|
||||
res.emplace_back(2);
|
||||
res.emplace_back(3);
|
||||
res.emplace_back(4);
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
res.push_front(NonDefaultConstructible{ 1 });
|
||||
res.push_front(NonDefaultConstructible{ 14 });
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
EXPECT_THAT(res.begin(), Eq(res.end()));
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, ResultStdForwardListShouldShrink) {
|
||||
// forward list doesn't have .erase function, bet has erase_after
|
||||
// in this case, if new size is 0 it must call clear, so we need to check two cases
|
||||
{
|
||||
// 1) when result should have more than 0 elements
|
||||
SerializationContext ctx{};
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
data.push_front(NonDefaultConstructible{1});
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
res.push_front(NonDefaultConstructible{21});
|
||||
res.push_front(NonDefaultConstructible{14});
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
auto resIt = res.begin();
|
||||
for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
|
||||
EXPECT_THAT(*resIt, Eq(*it));
|
||||
}
|
||||
EXPECT_THAT(resIt, Eq(res.end()));
|
||||
|
||||
}
|
||||
{
|
||||
// 1) when result should have 0 elements
|
||||
SerializationContext ctx{};
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
res.push_front(NonDefaultConstructible{1});
|
||||
res.push_front(NonDefaultConstructible{14});
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res.begin(), Eq(res.end()));
|
||||
|
||||
}
|
||||
|
||||
{
|
||||
// also check if correctly expands if source is bigger than destination
|
||||
SerializationContext ctx{};
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
data.push_front(NonDefaultConstructible{1});
|
||||
data.push_front(NonDefaultConstructible{14});
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
auto resIt = res.begin();
|
||||
for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
|
||||
EXPECT_THAT(*resIt, Eq(*it));
|
||||
}
|
||||
EXPECT_THAT(resIt, Eq(res.end()));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, StdSet) {
|
||||
{
|
||||
// also check if correctly expands if source is bigger than destination
|
||||
SerializationContext ctx{};
|
||||
std::set<NonDefaultConstructible> data;
|
||||
data.insert(NonDefaultConstructible{1});
|
||||
data.insert(NonDefaultConstructible{2});
|
||||
std::set<NonDefaultConstructible> res{};
|
||||
data.insert(NonDefaultConstructible{3});
|
||||
std::forward_list<NonDefaultConstructible> data{};
|
||||
data.push_front(NonDefaultConstructible{ 1 });
|
||||
data.push_front(NonDefaultConstructible{ 14 });
|
||||
std::forward_list<NonDefaultConstructible> res{};
|
||||
|
||||
ctx.createSerializer().ext(data, bitsery::ext::StdSet{10});
|
||||
ctx.createDeserializer().ext(res, bitsery::ext::StdSet{10});
|
||||
ctx.createSerializer().container(data, 10);
|
||||
ctx.createDeserializer().container(res, 10);
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
auto resIt = res.begin();
|
||||
for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
|
||||
EXPECT_THAT(*resIt, Eq(*it));
|
||||
}
|
||||
EXPECT_THAT(resIt, Eq(res.end()));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, StdMap) {
|
||||
SerializationContext ctx{};
|
||||
std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> data;
|
||||
data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
|
||||
TEST(DeserializeNonDefaultConstructible, StdSet)
|
||||
{
|
||||
SerializationContext ctx{};
|
||||
std::set<NonDefaultConstructible> data;
|
||||
data.insert(NonDefaultConstructible{ 1 });
|
||||
data.insert(NonDefaultConstructible{ 2 });
|
||||
std::set<NonDefaultConstructible> res{};
|
||||
data.insert(NonDefaultConstructible{ 3 });
|
||||
|
||||
std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> res{};
|
||||
data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
|
||||
data.emplace(NonDefaultConstructible{4}, NonDefaultConstructible{4});
|
||||
ctx.createSerializer().ext(data, bitsery::ext::StdSet{ 10 });
|
||||
ctx.createDeserializer().ext(res, bitsery::ext::StdSet{ 10 });
|
||||
|
||||
auto& ser = ctx.createSerializer();
|
||||
ser.ext(data, bitsery::ext::StdMap{10},[](decltype(ser)& ser, NonDefaultConstructible& key, NonDefaultConstructible& value) {
|
||||
ser.object(key);
|
||||
ser.object(value);
|
||||
});
|
||||
auto& des = ctx.createDeserializer();
|
||||
des.ext(res, bitsery::ext::StdMap{10},[](decltype(des)& des, NonDefaultConstructible& key, NonDefaultConstructible& value) {
|
||||
des.object(key);
|
||||
des.object(value);
|
||||
});
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, StdMap)
|
||||
{
|
||||
SerializationContext ctx{};
|
||||
std::unordered_map<NonDefaultConstructible,
|
||||
NonDefaultConstructible,
|
||||
HasherForNonDefaultConstructible>
|
||||
data;
|
||||
data.emplace(NonDefaultConstructible{ 2 }, NonDefaultConstructible{ 3 });
|
||||
|
||||
struct NonPolymorphicPointers {
|
||||
NonDefaultConstructible* pp;
|
||||
std::unique_ptr<NonDefaultConstructible> up;
|
||||
std::shared_ptr<NonDefaultConstructible> sp;
|
||||
std::weak_ptr<NonDefaultConstructible> wp;
|
||||
std::unordered_map<NonDefaultConstructible,
|
||||
NonDefaultConstructible,
|
||||
HasherForNonDefaultConstructible>
|
||||
res{};
|
||||
data.emplace(NonDefaultConstructible{ 2 }, NonDefaultConstructible{ 3 });
|
||||
data.emplace(NonDefaultConstructible{ 4 }, NonDefaultConstructible{ 4 });
|
||||
|
||||
auto& ser = ctx.createSerializer();
|
||||
ser.ext(data,
|
||||
bitsery::ext::StdMap{ 10 },
|
||||
[](decltype(ser)& ser,
|
||||
NonDefaultConstructible& key,
|
||||
NonDefaultConstructible& value) {
|
||||
ser.object(key);
|
||||
ser.object(value);
|
||||
});
|
||||
auto& des = ctx.createDeserializer();
|
||||
des.ext(res,
|
||||
bitsery::ext::StdMap{ 10 },
|
||||
[](decltype(des)& des,
|
||||
NonDefaultConstructible& key,
|
||||
NonDefaultConstructible& value) {
|
||||
des.object(key);
|
||||
des.object(value);
|
||||
});
|
||||
|
||||
EXPECT_THAT(res, ContainerEq(data));
|
||||
}
|
||||
|
||||
struct NonPolymorphicPointers
|
||||
{
|
||||
NonDefaultConstructible* pp;
|
||||
std::unique_ptr<NonDefaultConstructible> up;
|
||||
std::shared_ptr<NonDefaultConstructible> sp;
|
||||
std::weak_ptr<NonDefaultConstructible> wp;
|
||||
};
|
||||
|
||||
template <typename S>
|
||||
void serialize(S& s, NonPolymorphicPointers& o) {
|
||||
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
||||
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
||||
template<typename S>
|
||||
void
|
||||
serialize(S& s, NonPolymorphicPointers& o)
|
||||
{
|
||||
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
||||
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, NonPolymorphicPointerAndSmartPointer) {
|
||||
using SerContext = BasicSerializationContext<bitsery::ext::PointerLinkingContext>;
|
||||
SerContext ctx{};
|
||||
NonPolymorphicPointers data{};
|
||||
data.pp = new NonDefaultConstructible{3};
|
||||
data.up = std::unique_ptr<NonDefaultConstructible>(new NonDefaultConstructible{54});
|
||||
data.sp = std::shared_ptr<NonDefaultConstructible>(new NonDefaultConstructible{-481});
|
||||
data.wp = data.sp;
|
||||
TEST(DeserializeNonDefaultConstructible, NonPolymorphicPointerAndSmartPointer)
|
||||
{
|
||||
using SerContext =
|
||||
BasicSerializationContext<bitsery::ext::PointerLinkingContext>;
|
||||
SerContext ctx{};
|
||||
NonPolymorphicPointers data{};
|
||||
data.pp = new NonDefaultConstructible{ 3 };
|
||||
data.up =
|
||||
std::unique_ptr<NonDefaultConstructible>(new NonDefaultConstructible{ 54 });
|
||||
data.sp = std::shared_ptr<NonDefaultConstructible>(
|
||||
new NonDefaultConstructible{ -481 });
|
||||
data.wp = data.sp;
|
||||
|
||||
NonPolymorphicPointers res{};
|
||||
bitsery::ext::PointerLinkingContext plctx1{};
|
||||
ctx.createSerializer(plctx1).object(data);
|
||||
ctx.createDeserializer(plctx1).object(res);
|
||||
NonPolymorphicPointers res{};
|
||||
bitsery::ext::PointerLinkingContext plctx1{};
|
||||
ctx.createSerializer(plctx1).object(data);
|
||||
ctx.createDeserializer(plctx1).object(res);
|
||||
|
||||
EXPECT_THAT(*res.pp, Eq(*data.pp));
|
||||
delete res.pp;
|
||||
delete data.pp;
|
||||
EXPECT_THAT(*res.up, Eq(*data.up));
|
||||
EXPECT_THAT(*res.sp, Eq(*data.sp));
|
||||
EXPECT_THAT(*(res.wp.lock()), Eq(*(data.wp.lock())));
|
||||
EXPECT_THAT(*res.pp, Eq(*data.pp));
|
||||
delete res.pp;
|
||||
delete data.pp;
|
||||
EXPECT_THAT(*res.up, Eq(*data.up));
|
||||
EXPECT_THAT(*res.sp, Eq(*data.sp));
|
||||
EXPECT_THAT(*(res.wp.lock()), Eq(*(data.wp.lock())));
|
||||
}
|
||||
|
||||
class PolymorphicNDCBase {
|
||||
class PolymorphicNDCBase
|
||||
{
|
||||
public:
|
||||
virtual ~PolymorphicNDCBase() = 0;
|
||||
template <typename S>
|
||||
void serialize(S& ) {}
|
||||
virtual ~PolymorphicNDCBase() = 0;
|
||||
template<typename S>
|
||||
void serialize(S&)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
PolymorphicNDCBase::~PolymorphicNDCBase() = default;
|
||||
|
||||
class PolymorphicNDC1:public PolymorphicNDCBase {
|
||||
int8_t i{};
|
||||
friend class bitsery::Access;
|
||||
class PolymorphicNDC1 : public PolymorphicNDCBase
|
||||
{
|
||||
int8_t i{};
|
||||
friend class bitsery::Access;
|
||||
|
||||
template<typename S>
|
||||
void serialize(S& s)
|
||||
{
|
||||
s.value1b(i);
|
||||
}
|
||||
|
||||
template <typename S>
|
||||
void serialize(S& s) {
|
||||
s.value1b(i);
|
||||
}
|
||||
public:
|
||||
PolymorphicNDC1() = default;
|
||||
PolymorphicNDC1(int8_t v):i{v} {}
|
||||
bool operator == (const PolymorphicNDC1& other) const {
|
||||
return i == other.i;
|
||||
}
|
||||
PolymorphicNDC1() = default;
|
||||
PolymorphicNDC1(int8_t v)
|
||||
: i{ v }
|
||||
{
|
||||
}
|
||||
bool operator==(const PolymorphicNDC1& other) const { return i == other.i; }
|
||||
};
|
||||
|
||||
class PolymorphicNDC2:public PolymorphicNDCBase {
|
||||
uint16_t ui{};
|
||||
class PolymorphicNDC2 : public PolymorphicNDCBase
|
||||
{
|
||||
uint16_t ui{};
|
||||
|
||||
friend class bitsery::Access;
|
||||
friend class bitsery::Access;
|
||||
|
||||
template<typename S>
|
||||
void serialize(S& s)
|
||||
{
|
||||
s.value2b(ui);
|
||||
}
|
||||
|
||||
template <typename S>
|
||||
void serialize(S& s) {
|
||||
s.value2b(ui);
|
||||
}
|
||||
public:
|
||||
PolymorphicNDC2() = default;
|
||||
PolymorphicNDC2(uint16_t v):ui{v} {}
|
||||
bool operator == (const PolymorphicNDC2& other) const {
|
||||
return ui == other.ui;
|
||||
}
|
||||
|
||||
PolymorphicNDC2() = default;
|
||||
PolymorphicNDC2(uint16_t v)
|
||||
: ui{ v }
|
||||
{
|
||||
}
|
||||
bool operator==(const PolymorphicNDC2& other) const { return ui == other.ui; }
|
||||
};
|
||||
|
||||
|
||||
namespace bitsery {
|
||||
namespace ext {
|
||||
namespace ext {
|
||||
|
||||
template<>
|
||||
struct PolymorphicBaseClass<PolymorphicNDCBase> : PolymorphicDerivedClasses<PolymorphicNDC1, PolymorphicNDC2> {
|
||||
};
|
||||
}
|
||||
template<>
|
||||
struct PolymorphicBaseClass<PolymorphicNDCBase>
|
||||
: PolymorphicDerivedClasses<PolymorphicNDC1, PolymorphicNDC2>
|
||||
{
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct PolymorphicPointers {
|
||||
PolymorphicNDCBase* pp;
|
||||
std::unique_ptr<PolymorphicNDCBase> up;
|
||||
std::shared_ptr<PolymorphicNDCBase> sp;
|
||||
std::weak_ptr<PolymorphicNDCBase> wp;
|
||||
struct PolymorphicPointers
|
||||
{
|
||||
PolymorphicNDCBase* pp;
|
||||
std::unique_ptr<PolymorphicNDCBase> up;
|
||||
std::shared_ptr<PolymorphicNDCBase> sp;
|
||||
std::weak_ptr<PolymorphicNDCBase> wp;
|
||||
};
|
||||
|
||||
template <typename S>
|
||||
void serialize(S& s, PolymorphicPointers& o) {
|
||||
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
||||
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
||||
template<typename S>
|
||||
void
|
||||
serialize(S& s, PolymorphicPointers& o)
|
||||
{
|
||||
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
||||
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
||||
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
||||
}
|
||||
|
||||
TEST(DeserializeNonDefaultConstructible, PolymorphicPointerAndSmartPointer) {
|
||||
using TContext = std::tuple<bitsery::ext::PointerLinkingContext, bitsery::ext::PolymorphicContext<bitsery::ext::StandardRTTI>>;
|
||||
using SerContext = BasicSerializationContext<TContext>;
|
||||
SerContext ctx{};
|
||||
PolymorphicPointers data{};
|
||||
data.pp = new PolymorphicNDC1{-4};
|
||||
data.up = std::unique_ptr<PolymorphicNDCBase>(new PolymorphicNDC2{54});
|
||||
data.sp = std::shared_ptr<PolymorphicNDCBase>(new PolymorphicNDC1{15});
|
||||
data.wp = data.sp;
|
||||
TEST(DeserializeNonDefaultConstructible, PolymorphicPointerAndSmartPointer)
|
||||
{
|
||||
using TContext =
|
||||
std::tuple<bitsery::ext::PointerLinkingContext,
|
||||
bitsery::ext::PolymorphicContext<bitsery::ext::StandardRTTI>>;
|
||||
using SerContext = BasicSerializationContext<TContext>;
|
||||
SerContext ctx{};
|
||||
PolymorphicPointers data{};
|
||||
data.pp = new PolymorphicNDC1{ -4 };
|
||||
data.up = std::unique_ptr<PolymorphicNDCBase>(new PolymorphicNDC2{ 54 });
|
||||
data.sp = std::shared_ptr<PolymorphicNDCBase>(new PolymorphicNDC1{ 15 });
|
||||
data.wp = data.sp;
|
||||
|
||||
PolymorphicPointers res{};
|
||||
PolymorphicPointers res{};
|
||||
|
||||
TContext serCtx{};
|
||||
TContext desCtx{};
|
||||
TContext serCtx{};
|
||||
TContext desCtx{};
|
||||
|
||||
std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
||||
std::get<1>(desCtx).registerBasesList<typename SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
||||
std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(
|
||||
bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
||||
std::get<1>(desCtx).registerBasesList<typename SerContext::TDeserializer>(
|
||||
bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
||||
|
||||
ctx.createSerializer(serCtx).object(data);
|
||||
ctx.createDeserializer(desCtx).object(res);
|
||||
auto respp = dynamic_cast<PolymorphicNDC1*>(res.pp);
|
||||
auto resup = dynamic_cast<PolymorphicNDC2*>(res.up.get());
|
||||
auto ressp = dynamic_cast<PolymorphicNDC1*>(res.sp.get());
|
||||
auto reswp = dynamic_cast<PolymorphicNDC1*>(res.wp.lock().get());
|
||||
ctx.createSerializer(serCtx).object(data);
|
||||
ctx.createDeserializer(desCtx).object(res);
|
||||
auto respp = dynamic_cast<PolymorphicNDC1*>(res.pp);
|
||||
auto resup = dynamic_cast<PolymorphicNDC2*>(res.up.get());
|
||||
auto ressp = dynamic_cast<PolymorphicNDC1*>(res.sp.get());
|
||||
auto reswp = dynamic_cast<PolymorphicNDC1*>(res.wp.lock().get());
|
||||
|
||||
auto datapp = dynamic_cast<PolymorphicNDC1*>(data.pp);
|
||||
auto dataup = dynamic_cast<PolymorphicNDC2*>(data.up.get());
|
||||
auto datasp = dynamic_cast<PolymorphicNDC1*>(data.sp.get());
|
||||
auto datawp = dynamic_cast<PolymorphicNDC1*>(data.wp.lock().get());
|
||||
auto datapp = dynamic_cast<PolymorphicNDC1*>(data.pp);
|
||||
auto dataup = dynamic_cast<PolymorphicNDC2*>(data.up.get());
|
||||
auto datasp = dynamic_cast<PolymorphicNDC1*>(data.sp.get());
|
||||
auto datawp = dynamic_cast<PolymorphicNDC1*>(data.wp.lock().get());
|
||||
|
||||
EXPECT_THAT(respp, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(resup, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(ressp, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(reswp, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(respp, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(resup, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(ressp, ::testing::Ne(nullptr));
|
||||
EXPECT_THAT(reswp, ::testing::Ne(nullptr));
|
||||
|
||||
EXPECT_THAT(*respp, Eq(*datapp));
|
||||
delete res.pp;
|
||||
delete data.pp;
|
||||
EXPECT_THAT(*resup, Eq(*dataup));
|
||||
EXPECT_THAT(*ressp, Eq(*datasp));
|
||||
EXPECT_THAT(*reswp, Eq(*datawp));
|
||||
std::get<0>(serCtx).clearSharedState();
|
||||
std::get<0>(desCtx).clearSharedState();
|
||||
EXPECT_THAT(*respp, Eq(*datapp));
|
||||
delete res.pp;
|
||||
delete data.pp;
|
||||
EXPECT_THAT(*resup, Eq(*dataup));
|
||||
EXPECT_THAT(*ressp, Eq(*datasp));
|
||||
EXPECT_THAT(*reswp, Eq(*datawp));
|
||||
std::get<0>(serCtx).clearSharedState();
|
||||
std::get<0>(desCtx).clearSharedState();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user