void Database::Statement::write(const Serializable &s)
{
if(mOutputLevel == 0 || s.isInlineSerializable()) s.serialize(*this);
else {
String tmp;
JsonSerializer serializer(&tmp);
s.serialize(serializer);
write(tmp);
}
}
void test()
{
Deserializer::d()["TestSerializable"] = TestSerializable::returnNew;
TestSerializable testSerializable("important stuff");
ptree serial = testSerializable.serialize();
stringstream ss;
write_xml(ss, serial);
cout << "TestSerializable.serialize() to string:" << endl << ss.str() << endl;
Serializable * deserializedUncast = newDeserialize(serial);
//Serializable * deserializedUncast = Deserializer::d()["TestSerializable"]();
ptree serial2 = deserializedUncast->serialize();
stringstream ss2;
write_xml(ss2, serial2);
cout << "deserializedUncast->serialize() *post-returned* to string:" << endl << ss2.str() << endl;
TestSerializable * deserialized = dynamic_cast<TestSerializable *>(deserializedUncast);
cout << "deserialized->data: " << deserialized->data << endl;
}
Serializable * newDeserialize(ptree serial)
{
#if VERBOSE
cout << "registered types:" << endl;
for(map<string, Serializable * (*)()>::iterator iterator = Deserializer::d().begin(); iterator != Deserializer::d().end(); iterator++) {
cout << iterator->first << endl;
}
#endif
string type = serial.get<std::string>("type");
map<string, Serializable * (*)()>::iterator it = Deserializer::d().find(type);
if(it != Deserializer::d().end())
{
Serializable * toReturn = Deserializer::d()[type]();
toReturn->deserialize(serial);
#if VERBOSE
stringstream ss2;
write_xml(ss2, toReturn->serialize());
cout << "newDeserialize()->serialize() *pre-returned* to string:" << endl << ss2.str() << endl;
#endif
return toReturn;
}
else
{
cout<<"ERROR! No compatible deserialization function for " << type; //In case someone forgets to add a deserializer
throw 319;
}
}
bool OutXmlSerializer::save(Stream& stream)
{
XmlDocument doc;
XmlDeclaration* decl = zenic_new XmlDeclaration;
decl->setValue("xml");
decl->setAttribute("version","1.0");
decl->setAttribute("encoding","ISO-8859-1");
doc.addChild(decl);
XmlComment* comment = new XmlComment;
comment->setValue(" Cell XML Object Graph ");
doc.addChild(comment);
// add initial objects
for (uint i = 0, n = count(); i < n; ++i)
{
Serializable* initial = (*this)[i];
uint j,m;
for (j = 0, m = m_objects.count(); j < m; ++j)
{
if (m_objects[j] == initial)
break;
}
if (j == m_objects.count())
m_objects.pushBack(initial);
}
// build xml tree
XmlElement* root = new XmlElement;
root->setValue("zenic");
for (uint i = 0; i < m_objects.count(); ++i)
{
Serializable* object = m_objects[i];
ZENIC_ASSERT(object);
m_current = 0;
m_currentIndex = i;
object->serialize(*this);
ZENIC_ASSERT(m_current);
root->addChild(m_current);
}
doc.addChild(root);
// write tree to stream
if (!doc.save(stream))
return false;
return true;
}
bool Serializer::writeObject(Serializable& instance) {
ObjectData* data=new ObjectData();
instance.serialize(*data,*this);
processDataForWrite(data,*this);
if (!_datastream) {
string str=_dataFileName;
replaceEnvTags(str,_envMap);
create_directories(path(str).parent_path());
_datastream=new ofstream(str.c_str());
}
if (*_datastream) {
_objectWriter->writeObject(*_datastream,instance.className(),*data);
//TODO Change writer to get status flag
return true;
}
return false;
}
void Serializer::serialize(const std::string& key, const Serializable& sObj) {
auto newNode = util::make_unique<TxElement>(key);
rootElement_->LinkEndChild(newNode.get());
NodeSwitch nodeSwitch(*this, newNode.get());
sObj.serialize(*this);
}
