//===========================================
// Animation::Animation
//===========================================
Animation::Animation(const XmlNode data)
: Asset(internString("Animation")),
m_state(STOPPED),
m_frameReady(false) {
try {
XML_NODE_CHECK(data, Animation);
XmlAttribute attr = data.firstAttribute();
XML_ATTR_CHECK(attr, name);
m_name = internString(attr.getString());
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, duration);
m_duration = attr.getFloat();
uint_t f = 0;
XmlNode node = data.firstChild();
while (!node.isNull() && node.name() == "AnimFrame") {
AnimFrame frame(node);
frame.number = f;
m_frames.push_back(frame);
++f;
node = node.nextSibling();
}
}
catch (XmlException& e) {
e.prepend("Error parsing XML for instance of class Animation; ");
throw;
}
}
void XmlSchema::addSimpleVector(const XmlNode* child, String& structDefinition, size_t typeWidth,
String& readingFunction, String& writingFunction) const
{
assert(child != NULL);
XmlAttribute* type = child->findAttribute(ATTR_TYPE);
if (type == NULL)
{
return;
}
String typeString = T("std::vector<");
typeString += getSimpleTypeString(type);
typeString += T(">");
size_t thisWidth = typeString.size();
assert(thisWidth < typeWidth + 1);
for (size_t i = 0; i < typeWidth + 1 - thisWidth; ++i)
{
typeString += T(" ");
}
structDefinition += T(" ");
structDefinition += typeString;
structDefinition += getPluralName(child->getName());
structDefinition += T(";\r\n");
readingFunction += T("\r\n childNode = node->findFirstChild(");
readingFunction += LEFT_QUOTE;
readingFunction += child->getName();
readingFunction += T("\", iter);\r\n while (childNode != NULL)\r\n {\r\n ");
readingFunction += getPluralName(child->getName());
readingFunction += T(".resize(");
readingFunction += getPluralName(child->getName());
readingFunction += T(".size() + 1);\r\n ");
readingFunction += getPluralName(child->getName());
readingFunction += T(".back() = childNode->get");
String typeName = type->getString();
typeName[0] -= 32;
readingFunction += typeName;
readingFunction += T("();\r\n childNode = node->findNextChild(");
readingFunction += LEFT_QUOTE;
readingFunction += child->getName();
readingFunction += T("\", iter);\r\n }\r\n");
writingFunction += T("\r\n for (std::vector<");
writingFunction += getSimpleTypeString(type);
writingFunction += T(">::const_iterator iter = ");
writingFunction += getPluralName(child->getName());
writingFunction += T(".begin();\r\n iter != ");
writingFunction += getPluralName(child->getName());
writingFunction += T(".end();\r\n ++iter)\r\n {\r\n const ");
writingFunction += getSimpleTypeString(type);
writingFunction += T("& value = *iter;\r\n");
writingFunction += T(" childNode = node->addChild(");
writingFunction += LEFT_QUOTE;
writingFunction += child->getName();
writingFunction += T("\");\r\n childNode->set");
writingFunction += typeName;
writingFunction += T("(value);\r\n }\r\n");
}
//===========================================
// MusicTrack::MusicTrack
//===========================================
MusicTrack::MusicTrack(const XmlNode data)
: Asset(internString("MusicTrack")) {
string path;
try {
XML_NODE_CHECK(data, MusicTrack);
XmlAttribute attr = data.firstAttribute();
XML_ATTR_CHECK(attr, path);
stringstream ss;
ss << gGetWorkingDir() << "/" << attr.getString();
path = ss.str();
}
catch (XmlException& e) {
e.prepend("Error parsing XML for instance of class MusicTrack; ");
throw;
}
Audio audio;
audio.newMusicTrack(this, path);
}
void XmlSchema::addConstructorItem(const XmlNode* child, String& structDefinition, int& index) const
{
XmlAttribute* type = child->findAttribute(ATTR_TYPE);
bool recursive = (child->findAttribute(ATTR_RECURSIVE) != NULL);
if (type == NULL && !recursive)
{
return;
}
XmlAttribute* multiple = child->findAttribute(ATTR_MULTIPLE);
if (multiple != NULL && multiple->getBool())
{
//don't need to construct a vector member
return;
}
XmlAttribute* defaultAttribute = child->findAttribute(ATTR_DEFAULT);
if (type != NULL
&& Strcmp(type->getString(), T("string")) == 0
&& defaultAttribute == NULL)
{
//for String, need construction only when default value exist
return;
}
if (index == 0)
{
structDefinition += T(" ");
structDefinition += child->getParent()->getName();
structDefinition += T("()\r\n : ");
}
else
{
structDefinition += T(" , ");
}
if (recursive)
{
structDefinition += T("Child");
}
else
{
structDefinition += child->getName();
}
structDefinition += T("(");
++index;
if (defaultAttribute != NULL)
{
if (Strcmp(type->getString(), T("string")) == 0)
{
structDefinition += LEFT_QUOTE;
structDefinition += defaultAttribute->getString();
structDefinition += T("\"");
}
else
{
structDefinition += defaultAttribute->getString();
}
}
else
{
if (recursive)
{
structDefinition += T("NULL");
}
else
{
structDefinition += getTypeDefaultValue(type->getString());
}
}
structDefinition += T(")\r\n");
}
void XmlSchema::addSimpleMember(const XmlNode* child, String& structDefinition, size_t typeWidth,
String& readingFunction, String& writingFunction) const
{
assert(child != NULL);
XmlAttribute* type = child->findAttribute(ATTR_TYPE);
XmlAttribute* defaultAttribute = child->findAttribute(ATTR_DEFAULT);
bool inAttribute = (child->findAttribute(ATTR_ATTRIBUTE) != NULL);
if (type == NULL)
{
return;
}
String typeString = getSimpleTypeString(type);
size_t thisWidth = typeString.size();
assert(thisWidth < typeWidth + 1);
for (size_t i = 0; i < typeWidth + 1 - thisWidth; ++i)
{
typeString += T(" ");
}
structDefinition += T(" ");
structDefinition += typeString;
structDefinition += child->getName();
structDefinition += T(";\r\n");
readingFunction += inAttribute ? T("\r\n attribute = node->findAttribute(")
: T("\r\n childNode = node->findChild(");
readingFunction += LEFT_QUOTE;
readingFunction += child->getName();
readingFunction += inAttribute ? T("\");\r\n if (attribute != NULL)\r\n {\r\n ")
: T("\");\r\n if (childNode != NULL)\r\n {\r\n ");
readingFunction += child->getName();
readingFunction += inAttribute ? T(" = attribute->get")
: T(" = childNode->get");
String typeName = type->getString();
typeName[0] -= 32;
readingFunction += typeName;
readingFunction += T("();\r\n }\r\n");
writingFunction += T("\r\n if (");
writingFunction += child->getName();
writingFunction += T(" != ");
if (defaultAttribute != NULL)
{
//with initialized value
if (Strcmp(type->getString(), T("string")) == 0)
{
writingFunction += LEFT_QUOTE;
}
writingFunction += defaultAttribute->getString();
if (Strcmp(type->getString(), T("string")) == 0)
{
writingFunction += T("\"");
}
}
else
{
writingFunction += getTypeDefaultValue(type->getString());
}
writingFunction += inAttribute ? T(")\r\n {\r\n attribute = node->addAttribute(")
: T(")\r\n {\r\n childNode = node->addChild(");
writingFunction += LEFT_QUOTE;
writingFunction += child->getName();
writingFunction += inAttribute ? T("\");\r\n attribute->set")
: T("\");\r\n childNode->set");
typeName = type->getString();
typeName[0] -= 32;
writingFunction += typeName;
writingFunction += T("(");
writingFunction += child->getName();
writingFunction += T(");\r\n }\r\n");
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//parse data schema from node
//src data node
//dst schema node
bool XmlSchema::parseNodeStruct(XmlNode* dst, XmlNode* src)
{
assert(dst != NULL);
assert(src != NULL);
NodeIterator nodeIterator;
AttributeIterator attriIterator;
for (XmlAttribute* attribute = src->getFirstAttribute(attriIterator);
attribute != NULL;
attribute = src->getNextAttribute(attriIterator))
{
XmlNode* structure = dst->findChild(attribute->getName());
if (structure == NULL)
{
//first time show up
structure = dst->addChild(attribute->getName());
structure->addAttribute(ATTR_TYPE, guessType(attribute->getString()));
structure->addAttribute(ATTR_ATTRIBUTE, T("true"));
}
}
for (XmlNode* child = src->getFirstChild(nodeIterator);
child != NULL;
child = src->getNextChild(nodeIterator))
{
if (child->getType() != ELEMENT)
{
continue;
}
XmlNode* structure = dst->findChild(child->getName());
if (structure == NULL)
{
//first time show up
bool recursive = false;
const XmlNode* parent = dst;
while (parent != NULL)
{
if (Strcmp(parent->getName(), child->getName()) == 0)
{
recursive = true;
break;
}
parent = parent->getParent();
}
structure = dst->addChild(child->getName());
if (recursive)
{
structure->addAttribute(ATTR_RECURSIVE, T("true"));
}
else if (!child->hasChild() && !child->hasAttribute())
{
//simple type, must have a type attribute
structure->addAttribute(ATTR_TYPE, guessType(child->getString()));
}
}
else if (structure->findAttribute(ATTR_ATTRIBUTE) != NULL)
{
//child and attribute can't have same name
return false;
}
XmlAttribute* multiple = structure->findAttribute(ATTR_MULTIPLE);
if (multiple == NULL || !multiple->getBool())
{
NodeIterator iter;
if (src->findFirstChild(child->getName(), iter) != NULL
&& src->findNextChild(child->getName(), iter) != NULL)
{
if (multiple == NULL)
{
multiple = structure->addAttribute(ATTR_MULTIPLE);
}
multiple->setBool(true);
}
}
if (!structure->findAttribute(ATTR_RECURSIVE) && (child->hasChild() || child->hasAttribute()))
{
parseNodeStruct(structure, child);
}
}
return true;
}
bool Test::testCase1() const {
bool pass = true;
bool b = false;
if (m_verbose) cout << "\tCASE 1: Parsing good document and checking tree\n";
try {
XmlDocument doc;
doc.parse("./test1.xml");
/*
<?xml version="1.0" encoding="utf-8"?>
<element1 a="1" b="2">
<element2 c="3" d="true"/>
<element3>Hello World!</element3>
<element4 a="123">
<element5 yes="no">
<element6 str="This is a string" num="4.5"/>
<element7>99.8</element7>
</element5>
</element4>
</element1>
*/
XmlNode node = doc.firstNode();
node = node.nextSibling();
SUBCASE_CHECK_CRITICAL(!node.isNull());
SUBCASE_CHECK(node.name().compare("element1") == 0, pass, b);
XmlAttribute attr = node.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("a") == 0, pass, b);
SUBCASE_CHECK(attr.getInt() == 1, pass, b);
attr = attr.nextAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("b") == 0, pass, b);
SUBCASE_CHECK(attr.getInt() == 2, pass, b);
{
XmlNode node_ = node.firstChild();
SUBCASE_CHECK_CRITICAL(!node_.isNull());
SUBCASE_CHECK(node_.name().compare("element2") == 0, pass, b);
XmlAttribute attr = node_.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("c") == 0, pass, b);
SUBCASE_CHECK(attr.getInt() == 3, pass, b);
attr = attr.nextAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("d") == 0, pass, b);
SUBCASE_CHECK(attr.getString().compare("true") == 0, pass, b);
node_ = node_.nextSibling();
SUBCASE_CHECK_CRITICAL(!node_.isNull());
SUBCASE_CHECK(node_.name().compare("element3") == 0, pass, b);
SUBCASE_CHECK(node_.getString().compare("Hello World!") == 0, pass, b);
node_ = node_.nextSibling();
SUBCASE_CHECK_CRITICAL(!node_.isNull());
SUBCASE_CHECK(node_.name().compare("element4") == 0, pass, b);
attr = node_.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("a") == 0, pass, b);
SUBCASE_CHECK(attr.getInt() == 123, pass, b);
{
XmlNode node__ = node_.firstChild();
SUBCASE_CHECK_CRITICAL(!node__.isNull());
SUBCASE_CHECK(node__.name().compare("element5") == 0, pass, b);
XmlAttribute attr = node__.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("yes") == 0, pass, b);
SUBCASE_CHECK(attr.getString().compare("no") == 0, pass, b);
{
XmlNode node___ = node__.firstChild();
SUBCASE_CHECK_CRITICAL(!node___.isNull());
SUBCASE_CHECK(node___.name().compare("element6") == 0, pass, b);
XmlAttribute attr = node___.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("str") == 0, pass, b);
SUBCASE_CHECK(attr.getString().compare("This is a string") == 0, pass, b);
attr = attr.nextAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("num") == 0, pass, b);
SUBCASE_CHECK(attr.getFloat() == 4.5, pass, b);
}
}
}
}
catch (XmlException& e) {
pass = false;
if (m_verbose) {
cout << e.what() << "\n";
}
}
if (m_verbose) cout << (pass ? "\tPASS\n" : "\tFAIL\n");
return pass;
}
bool Test::testCase4() const {
if (m_verbose) cout << "\tCase 4: Move node between documents (2)\n";
/*
<nodeA>
<nodeB a="1" b="two" c="3.4"/>
<nodeC d="true">
<nodeD>
Hello World!
</nodeD>
<nodeE>
Goodbye World!
</nodeE>
</nodeC>
</nodeA>
*/
XmlDocument doc2;
try {
XmlDocument doc1;
doc1.parse("./test4.xml");
XmlNode node = doc1.firstNode();
XML_NODE_CHECK(node, nodeA);
node = node.firstChild();
XML_NODE_CHECK(node, nodeB);
node = node.nextSibling();
XML_NODE_CHECK(node, nodeC);
XmlNode node_ = doc2.addNode("MyNode");
node_.addNode(node);
} // doc1 destroyed here
catch (XmlException& e) {
if (m_verbose) {
cout << e.what() << "\n";
}
return false;
}
bool pass = true;
bool b = false;
XmlNode node = doc2.firstNode();
SUBCASE_CHECK_CRITICAL(!node.isNull());
SUBCASE_CHECK(node.name().compare("MyNode") == 0, pass, b);
XmlNode node_ = node.firstChild();
SUBCASE_CHECK_CRITICAL(!node_.isNull());
SUBCASE_CHECK(node_.name().compare("nodeC") == 0, pass, b);
XmlAttribute attr = node_.firstAttribute();
SUBCASE_CHECK_CRITICAL(!attr.isNull());
SUBCASE_CHECK(attr.name().compare("d") == 0, pass, b);
SUBCASE_CHECK(attr.getString().compare("true") == 0, pass, b);
XmlNode node__ = node_.firstChild();
SUBCASE_CHECK_CRITICAL(!node__.isNull());
SUBCASE_CHECK(node__.name().compare("nodeD") == 0, pass, b);
node__ = node__.nextSibling();
SUBCASE_CHECK_CRITICAL(!node__.isNull());
SUBCASE_CHECK(node__.name().compare("nodeE") == 0, pass, b);
if (m_verbose) cout << (pass ? "\tPASS\n" : "\tFAIL\n");
return pass;
}
//===========================================
// Entity::Entity
//===========================================
Entity::Entity(const XmlNode data)
: Asset(internString("Entity")),
m_silent(false),
m_parent(NULL) {
AssetManager assetManager;
ShapeFactory shapeFactory;
try {
setSilent(true);
XML_NODE_CHECK(data, Entity);
XmlAttribute attr = data.firstAttribute();
XML_ATTR_CHECK(attr, type);
m_type = internString(attr.getString());
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, name);
m_name = internString(attr.getString());
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, x);
m_transl.x = attr.getFloat();
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, y);
m_transl.y = attr.getFloat();
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, z);
m_z = attr.getFloat();
// So that no Z values are 'exactly' equal
m_z += 0.1f * static_cast<float32_t>(rand()) / static_cast<float32_t>(RAND_MAX);
attr = attr.nextAttribute();
XML_ATTR_CHECK(attr, rot);
float32_t rot = attr.getFloat();
XmlNode node = data.firstChild();
if (!node.isNull() && node.name() == "shape") {
m_shape = unique_ptr<Shape>(shapeFactory.create(node.firstChild()));
node = node.nextSibling();
}
m_rot = 0;
setRotation(rot);
XML_NODE_CHECK(node, scale);
m_scale = Vec2f(1.f, 1.f);
setScale(Vec2f(node.firstChild()));
node = node.nextSibling();
XML_NODE_CHECK(node, fillColour);
m_fillColour = Colour(node.firstChild());
node = node.nextSibling();
XML_NODE_CHECK(node, lineColour);
m_lineColour = Colour(node.firstChild());
node = node.nextSibling();
XML_NODE_CHECK(node, lineWidth);
m_lineWidth = node.getInt();
node = node.nextSibling();
XML_NODE_CHECK(node, children);
XmlNode node_ = node.firstChild();
while (!node_.isNull() && node_.name() == "child") {
XmlAttribute attr = node_.firstAttribute();
if (!attr.isNull() && attr.name() == "ptr") {
long id = attr.getLong();
pEntity_t child = boost::dynamic_pointer_cast<Entity>(assetManager.getAssetPointer(id));
if (!child)
throw XmlException("Bad entity asset id", __FILE__, __LINE__);
addChild(child);
}
node_ = node_.nextSibling();
}
setSilent(false);
++m_count;
}
catch (XmlException& e) {
e.prepend("Error parsing XML for instance of class Entity; ");
throw;
}
recomputeBoundary();
}
//===========================================
// Entity::assignData
//===========================================
void Entity::assignData(const XmlNode data) {
if (data.isNull() || data.name() != "Entity") return;
AssetManager assetManager;
ShapeFactory shapeFactory;
try {
bool silent = isSilent();
setSilent(true);
XmlAttribute attr = data.firstAttribute();
if (!attr.isNull() && attr.name() == "type") {
m_type = internString(attr.getString());
attr = attr.nextAttribute();
}
if (!attr.isNull() && attr.name() == "name") {
m_name = internString(attr.getString());
attr = attr.nextAttribute();
}
Vec2f transl = m_transl;
if (!attr.isNull() && attr.name() == "x") {
transl.x = attr.getFloat();
attr = attr.nextAttribute();
}
if (!attr.isNull() && attr.name() == "y") {
transl.y = attr.getFloat();
attr = attr.nextAttribute();
}
setTranslation(transl);
if (!attr.isNull() && attr.name() == "z") {
m_z = attr.getFloat();
// So that no Z values are 'exactly' equal
m_z += 0.1f * static_cast<float32_t>(rand()) / static_cast<float32_t>(RAND_MAX);
attr = attr.nextAttribute();
}
XmlNode node = data.firstChild();
if (!node.isNull() && node.name() == "shape") {
m_shape = unique_ptr<Shape>(shapeFactory.create(node.firstChild()));
node = node.nextSibling();
}
if (!node.isNull() && node.name() == "scale") {
setScale(Vec2f(node.firstChild()));
node = node.nextSibling();
}
if (!attr.isNull() && attr.name() == "rot") {
setRotation(attr.getFloat());
}
if (!node.isNull() && node.name() == "fillColour") {
m_fillColour = Colour(node.firstChild());
node = node.nextSibling();
}
if (!node.isNull() && node.name() == "lineColour") {
m_lineColour = Colour(node.firstChild());
node = node.nextSibling();
}
if (!node.isNull() && node.name() == "lineWidth") {
m_lineWidth = node.getInt();
node = node.nextSibling();
}
if (!node.isNull() && node.name() == "children") {
XmlNode node_ = node.firstChild();
while (!node_.isNull() && node_.name() == "child") {
XmlAttribute attr = node_.firstAttribute();
if (!attr.isNull() && attr.name() == "ptr") {
long id = attr.getLong();
pEntity_t child = boost::dynamic_pointer_cast<Entity>(assetManager.getAssetPointer(id));
if (!child)
throw XmlException("Bad entity asset id", __FILE__, __LINE__);
addChild(child);
}
node_ = node_.nextSibling();
}
}
setSilent(silent);
}
catch (XmlException& e) {
e.prepend("Error parsing XML for instance of class Entity; ");
throw;
}
recomputeBoundary();
}
