void Processor::deserialize(XmlDeserializer& s) {
// meta data
metaDataContainer_.deserialize(s);
// misc settings
s.deserialize("name", id_);
guiName_ = id_;
// deserialize properties
PropertyOwner::deserialize(s);
// ---
// the following entities are static resources that should not be dynamically created by the serializer
//
const bool usePointerContentSerialization = s.getUsePointerContentSerialization();
s.setUsePointerContentSerialization(true);
// deserialize inports using a temporary map
map<string, Port*> inportMap;
for (vector<Port*>::const_iterator it = inports_.begin(); it != inports_.end(); ++it)
inportMap[(*it)->getID()] = *it;
try {
s.deserialize("Inports", inportMap, "Port", "name");
}
catch (XmlSerializationNoSuchDataException& /*e*/){
// port key missing => just ignore
s.removeLastError();
}
// deserialize outports using a temporary map
map<string, Port*> outportMap;
for (vector<Port*>::const_iterator it = outports_.begin(); it != outports_.end(); ++it)
outportMap[(*it)->getID()] = *it;
try {
s.deserialize("Outports", outportMap, "Port", "name");
}
catch (XmlSerializationNoSuchDataException& /*e*/){
// port key missing => just ignore
s.removeLastError();
}
// deserialize interaction handlers using a temporary map
map<string, InteractionHandler*> handlerMap;
const std::vector<InteractionHandler*>& handlers = getInteractionHandlers();
for (vector<InteractionHandler*>::const_iterator it = handlers.begin(); it != handlers.end(); ++it)
handlerMap[(*it)->getID()] = *it;
try {
s.deserialize("InteractionHandlers", handlerMap, "Handler", "name");
}
catch (XmlSerializationNoSuchDataException& /*e*/){
// interaction handler key missing => just ignore
s.removeLastError();
}
s.setUsePointerContentSerialization(usePointerContentSerialization);
// --- static resources end ---
firstProcessAfterDeserialization_ = true;
}
void PropertyVector::deserialize(XmlDeserializer& s) {
Property::deserialize(s);
// deserialize the properties of the processor
typedef std::map<std::string, Property*> PropertyMapType;
PropertyMapType propertyMap;
for (std::vector<Property*>::const_iterator it = properties_.begin(); it != properties_.end(); ++it) {
propertyMap[(*it)->getID()] = *it;
}
const bool usePointerContentSerialization = s.getUsePointerContentSerialization();
s.setUsePointerContentSerialization(true);
s.deserialize("ElementProperties", propertyMap, "Property", "name");
s.setUsePointerContentSerialization(usePointerContentSerialization);
}
void PropertyOwner::deserialize(XmlDeserializer& s) {
// create temporary property map for deserialization
std::map<std::string, Property*> propertyMap;
for (std::vector<Property*>::const_iterator it = properties_.begin(); it != properties_.end(); ++it)
propertyMap[(*it)->getID()] = *it;
// deserialize properties
const bool usePointerContentSerialization = s.getUsePointerContentSerialization();
s.setUsePointerContentSerialization(true);
try {
s.deserialize("Properties", propertyMap, "Property", "name");
}
catch (SerializationException& e) {
LWARNING(e.what());
}
s.setUsePointerContentSerialization(usePointerContentSerialization);
}
/**
* Tests serialization and deserialization using pointer content serialization
* mixed up with using XML attributes.
*
* @attention This is a grey box test which uses implementation details
* to keep the test as short as possible. That is why
* you have to consider changing the test every time
* the implementation details have changed.
*/
void testUsePointerContentSerialization() {
int i = 1;
int* ip = &i;
std::vector<int*> v;
v.push_back(new int(2));
std::map<std::string, int*> m;
m["three"] = new int(3);
std::stringstream stream;
XmlSerializer s;
s.setUsePointerContentSerialization(true);
s.serialize("i", i);
s.serialize("ip", ip);
s.serialize("v", v);
s.serialize("m", m, "number");
s.setUseAttributes(true);
s.serialize("ai", i);
s.serialize("aip", ip);
s.serialize("av", v);
s.serialize("am", m, "number");
s.write(stream);
// Reset all variables to default values...
i = 0;
ip = new int(0);
*v[0] = 0;
*m["three"] = 0;
int ai = 0;
int* aip = new int(0);
std::vector<int*> av;
av.push_back(new int(0));
std::map<std::string, int*> am;
am["three"] = new int(0);
XmlDeserializer d;
d.read(stream);
d.setUsePointerContentSerialization(true);
d.deserialize("i", i);
d.deserialize("ip", ip);
d.deserialize("v", v);
d.deserialize("m", m, "number");
d.setUseAttributes(true);
d.deserialize("ai", ai);
d.deserialize("aip", aip);
d.deserialize("av", av);
d.deserialize("am", am, "number");
test(i, 1, "i incorrect deserialized");
test(ip != &i, "ip is pointing to adress of i");
test(*ip, 1, "ip incorrect deserialized");
test(v.size() == 1, "v: incorrect size");
test(*v[0], 2, "v: first item incorrect deserialized");
test(m.size() == 1, "m: incorrect size");
test(*m["three"], 3, "m: first item incorrect deserialized");
test(ai, 1, "ai incorrect deserialized");
test(aip != &ai, "aip is pointing to adress of ai");
test(*aip, 1, "aip incorrect deserialized");
test(av.size() == 1, "av: incorrect size");
test(*av[0], 2, "av: first item incorrect deserialized");
test(am.size() == 1, "am: incorrect size");
test(*am["three"], 3, "am: first item incorrect deserialized");
delete ip;
delete v[0];
delete m["three"];
delete aip;
delete av[0];
delete am["three"];
}
