//=========================================== // 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(); }