C++ Serializable::serialize方法代码示例

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);
}