void PropertyEditorWidgetMetaData::deserialize(Deserializer& d) {
d.deserialize("position", position_);
d.deserialize("dimensions", dimensions_);
d.deserialize("visibility", visibility_);
d.deserialize("dockstatus", dockStatus_);
if (dockStatus_.empty()) dockStatus_="Floating";
}
TEST(DeserializerTest, ClearContext) {
AmfByteArray ba(v8 { 0x1 });
v8 data {
0x0c, 0x03, 0x01,
0x0c, 0x00,
};
Deserializer d;
auto it = data.cbegin();
auto end = data.cend();
ASSERT_EQ(ba, d.deserialize(it, end).as<AmfByteArray>());
d.clearContext();
ASSERT_THROW(d.deserialize(it, end), std::out_of_range);
}
TEST(DeserializerTest, InstanceContext) {
AmfByteArray ba(v8 { 0x1 });
v8 data {
0x0c, 0x03, 0x01,
0x0c, 0x00,
};
Deserializer d;
auto it = data.cbegin();
auto end = data.cend();
ASSERT_EQ(ba, d.deserialize(it, end).as<AmfByteArray>());
ASSERT_EQ(data.cbegin() + 3, it);
ASSERT_EQ(ba, d.deserialize(it, end).as<AmfByteArray>());
ASSERT_EQ(end, it);
}
void PropertyOwner::deserialize(Deserializer& d) {
// This is for finding renamed composites, and moving old properties to new composites.
NodeVersionConverter tvc(this, &PropertyOwner::findPropsForComposites);
d.convertVersion(&tvc);
std::vector<std::string> ownedIdentifiers;
d.deserialize("OwnedPropertyIdentifiers", ownedIdentifiers, "PropertyIdentifier");
auto des = util::IdentifiedDeserializer<std::string, Property*>("Properties", "Property")
.setGetId([](Property* const& p) { return p->getIdentifier(); })
.setMakeNew([]() { return nullptr; })
.setNewFilter([&](const std::string& id, size_t ind) {
return util::contains(ownedIdentifiers, id);
})
.onNew([&](Property*& p) { addProperty(p, true); })
.onRemove([&](const std::string& id) {
if (util::contains_if(ownedProperties_, [&](std::unique_ptr<Property>& op) {
return op->getIdentifier() == id;
})) {
delete removeProperty(id);
}
});
des(d, properties_);
}
void SlamDriver::loadMap()
{
Deserializer s;
s.open("save/", "map.yml");
s.deserialize();
mCamera = s.getObjectForOwner<CameraModel>();
std::unique_ptr<SlamMap> map = s.getObjectForOwner<SlamMap>();
mSlam.init(mCamera.get(), std::move(map));
}
void RBFVectorFieldGenerator2D::deserialize(Deserializer& d) {
std::vector<dvec2> sx;
std::vector<dvec2> sy;
d.deserialize("samplesx", sx, "samplex");
d.deserialize("samplesy", sy, "sampley");
Processor::deserialize(d);
for (size_t i = 0; i < sx.size(); i++) {
samples_.emplace_back(sx[i], sy[i]);
}
}
static void deserializesTo(const T& expected, v8 data, int left = 0) {
SCOPED_TRACE(::testing::PrintToString(expected) + " = " + ::testing::PrintToString(data));
auto it = data.cbegin();
try {
Deserializer d;
T i = d.deserialize(it, data.cend()).as<T>();
ASSERT_EQ(expected, i);
T j = *d.deserialize(data).asPtr<T>();
ASSERT_EQ(expected, j);
DeserializationContext ctx;
T k = Deserializer::deserialize(data, ctx).as<T>();
ASSERT_EQ(expected, k);
} catch(std::exception& e) {
FAIL() << "Deserialization threw exception:\n"
<< e.what() ;
}
ASSERT_EQ(left, data.cend() - it)
<< "Expected " << left
<< " bytes left, got " << (data.cend() - it)
<< " bytes left";
}
void Property::deserialize(Deserializer& d) {
std::string className;
d.deserialize("type", className, true);
d.deserialize("identifier", identifier_, true);
notifyObserversOnSetIdentifier(identifier_);
d.deserialize(displayName_.name, displayName_.value, true);
notifyObserversOnSetDisplayName(displayName_);
semantics_.deserialize(d);
notifyObserversOnSetSemantics(semantics_);
int mode = static_cast<int>(usageMode_.value);
d.deserialize(usageMode_.name, mode);
usageMode_ = static_cast<UsageMode>(mode);
notifyObserversOnSetUsageMode(usageMode_);
visible_.deserialize(d);
notifyObserversOnSetVisible(visible_);
readOnly_.deserialize(d);
notifyObserversOnSetReadOnly(readOnly_);
MetaDataOwner::deserialize(d);
}
TEST(DeserializerTest, IncorrectTypeRef) {
Deserializer d;
ASSERT_EQ(AmfArray(), d.deserialize(v8 { 0x09, 0x01, 0x01 }).as<AmfArray>());
ASSERT_EQ(AmfArray(), d.deserialize(v8 { 0x09, 0x00 }).as<AmfArray>());
ASSERT_THROW(d.deserialize(v8 { 0x10, 0x00 }), std::invalid_argument);
}
TEST(DeserializerTest, UnknownType) {
Deserializer d;
ASSERT_THROW(d.deserialize({ AMF_DICTIONARY + 1 }), std::invalid_argument);
ASSERT_THROW(d.deserialize({ 0xff }), std::invalid_argument);
}
bool Entity::load_from(const char* file) {
Deserializer des;
return des.deserialize(file, *this);
}
void ImageLabel::deserialize(Deserializer& d) {
d.deserialize("labelName", name_, SerializationTarget::Attribute);
d.deserialize("topLeft", startPoint_);
d.deserialize("size", rectSize_);
}
void ImageEditorProperty::deserialize(Deserializer& d) {
FileProperty::deserialize(d);
d.deserialize("Dimension", dimensions_);
d.deserialize("Labels", labels_, "Label");
}
void CompositeProperty::deserialize(Deserializer& d) {
Property::deserialize(d);
PropertyOwner::deserialize(d);
d.deserialize("collapsed", collapsed_);
}
void KeyboardEvent::deserialize(Deserializer& d) {
InteractionEvent::deserialize(d);
d.deserialize("state", state_);
d.deserialize("key", key_);
}
void PositionMetaData::deserialize(Deserializer& d) {
std::string className;
d.deserialize("type", className, SerializationTarget::Attribute);
d.deserialize("position", value_);
}
void IntegrateGCommand::deserialize(Deserializer& deserializer, Serialization& serialization, Context& context)
{
sensor = deserializer.deserialize();
duration_s = deserializer.deserialize();
deserializer.deserialize((uint8_t*)calibration_offset.values, sizeof(calibration_offset.values));
}
