llxmlnode.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:13k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llxmlnode.h
  3.  * @brief LLXMLNode definition
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_LLXMLNODE_H
  33. #define LL_LLXMLNODE_H
  34. #ifndef XML_STATIC
  35. #define XML_STATIC
  36. #endif
  37. #ifdef LL_STANDALONE
  38. #include <expat.h>
  39. #else
  40. #include "expat/expat.h"
  41. #endif
  42. #include <map>
  43. #include "indra_constants.h"
  44. #include "llpointer.h"
  45. #include "llthread.h" // LLThreadSafeRefCount
  46. #include "llstring.h"
  47. #include "llstringtable.h"
  48. #include "llfile.h"
  49. class LLVector3;
  50. class LLVector3d;
  51. class LLQuaternion;
  52. class LLUUID;
  53. class LLColor4;
  54. class LLColor4U;
  55. struct CompareAttributes
  56. {
  57. bool operator()(const LLStringTableEntry* const lhs, const LLStringTableEntry* const rhs) const
  58. {
  59. if (lhs == NULL)
  60. return TRUE;
  61. if (rhs == NULL)
  62. return FALSE;
  63. return strcmp(lhs->mString, rhs->mString) < 0;
  64. }
  65. };
  66. // Defines a simple node hierarchy for reading and writing task objects
  67. class LLXMLNode;
  68. typedef LLPointer<LLXMLNode> LLXMLNodePtr;
  69. typedef std::multimap<std::string, LLXMLNodePtr > LLXMLNodeList;
  70. typedef std::multimap<const LLStringTableEntry *, LLXMLNodePtr > LLXMLChildList;
  71. typedef std::map<const LLStringTableEntry *, LLXMLNodePtr, CompareAttributes> LLXMLAttribList;
  72. class LLColor4;
  73. class LLColor4U;
  74. class LLQuaternion;
  75. class LLVector3;
  76. class LLVector3d;
  77. class LLVector4;
  78. class LLVector4U;
  79. struct LLXMLChildren : public LLThreadSafeRefCount
  80. {
  81. LLXMLChildList map; // Map of children names->pointers
  82. LLXMLNodePtr head; // Head of the double-linked list
  83. LLXMLNodePtr tail; // Tail of the double-linked list
  84. };
  85. typedef LLPointer<LLXMLChildren> LLXMLChildrenPtr;
  86. class LLXMLNode : public LLThreadSafeRefCount
  87. {
  88. public:
  89. enum ValueType
  90. {
  91. TYPE_CONTAINER, // A node which contains nodes
  92. TYPE_UNKNOWN, // A node loaded from file without a specified type
  93. TYPE_BOOLEAN, // "true" or "false"
  94. TYPE_INTEGER, // any integer type: U8, U32, S32, U64, etc.
  95. TYPE_FLOAT, // any floating point type: F32, F64
  96. TYPE_STRING, // a string
  97. TYPE_UUID, // a UUID
  98. TYPE_NODEREF, // the ID of another node in the hierarchy to reference
  99. };
  100. enum Encoding
  101. {
  102. ENCODING_DEFAULT = 0,
  103. ENCODING_DECIMAL,
  104. ENCODING_HEX,
  105. // ENCODING_BASE32, // Not implemented yet
  106. };
  107. protected:
  108. ~LLXMLNode();
  109. public:
  110. LLXMLNode();
  111. LLXMLNode(const char* name, BOOL is_attribute);
  112. LLXMLNode(LLStringTableEntry* name, BOOL is_attribute);
  113. LLXMLNode(const LLXMLNode& rhs);
  114. LLXMLNodePtr deepCopy();
  115. BOOL isNull();
  116. BOOL deleteChild(LLXMLNode* child);
  117.     void addChild(LLXMLNodePtr new_child, LLXMLNodePtr after_child = LLXMLNodePtr(NULL)); 
  118.     void setParent(LLXMLNodePtr new_parent); // reparent if necessary
  119.     // Serialization
  120. static bool parseFile(
  121. const std::string& filename,
  122. LLXMLNodePtr& node, 
  123. LLXMLNode* defaults_tree);
  124. static bool parseBuffer(
  125. U8* buffer,
  126. U32 length,
  127. LLXMLNodePtr& node, 
  128. LLXMLNode* defaults);
  129. static bool parseStream(
  130. std::istream& str,
  131. LLXMLNodePtr& node, 
  132. LLXMLNode* defaults);
  133. static bool updateNode(
  134. LLXMLNodePtr& node,
  135. LLXMLNodePtr& update_node);
  136. static LLXMLNodePtr replaceNode(LLXMLNodePtr node, LLXMLNodePtr replacement_node);
  137. static bool getLayeredXMLNode(const std::string &xui_filename, LLXMLNodePtr& root,
  138.   const std::vector<std::string>& paths);
  139. // Write standard XML file header:
  140. // <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
  141. static void writeHeaderToFile(LLFILE *out_file);
  142. // Write XML to file with one attribute per line.
  143. // XML escapes values as they are written.
  144.     void writeToFile(LLFILE *out_file, const std::string& indent = std::string(), bool use_type_decorations=true);
  145.     void writeToOstream(std::ostream& output_stream, const std::string& indent = std::string(), bool use_type_decorations=true);
  146.     // Utility
  147.     void findName(const std::string& name, LLXMLNodeList &results);
  148.     void findName(LLStringTableEntry* name, LLXMLNodeList &results);
  149.     void findID(const std::string& id, LLXMLNodeList &results);
  150.     virtual LLXMLNodePtr createChild(const char* name, BOOL is_attribute);
  151.     virtual LLXMLNodePtr createChild(LLStringTableEntry* name, BOOL is_attribute);
  152.     // Getters
  153.     U32 getBoolValue(U32 expected_length, BOOL *array);
  154.     U32 getByteValue(U32 expected_length, U8 *array, Encoding encoding = ENCODING_DEFAULT);
  155.     U32 getIntValue(U32 expected_length, S32 *array, Encoding encoding = ENCODING_DEFAULT);
  156.     U32 getUnsignedValue(U32 expected_length, U32 *array, Encoding encoding = ENCODING_DEFAULT);
  157.     U32 getLongValue(U32 expected_length, U64 *array, Encoding encoding = ENCODING_DEFAULT);
  158.     U32 getFloatValue(U32 expected_length, F32 *array, Encoding encoding = ENCODING_DEFAULT);
  159.     U32 getDoubleValue(U32 expected_length, F64 *array, Encoding encoding = ENCODING_DEFAULT);
  160.     U32 getStringValue(U32 expected_length, std::string *array);
  161.     U32 getUUIDValue(U32 expected_length, LLUUID *array);
  162.     U32 getNodeRefValue(U32 expected_length, LLXMLNode **array);
  163. BOOL hasAttribute(const char* name );
  164.         // these are designed to be more generic versions of the functions
  165.     // rather than relying on LL-types
  166.     bool getAttribute_bool(const char* name, bool& value ); 
  167. BOOL getAttributeBOOL(const char* name, BOOL& value );
  168. BOOL getAttributeU8(const char* name, U8& value );
  169. BOOL getAttributeS8(const char* name, S8& value );
  170. BOOL getAttributeU16(const char* name, U16& value );
  171. BOOL getAttributeS16(const char* name, S16& value );
  172. BOOL getAttributeU32(const char* name, U32& value );
  173. BOOL getAttributeS32(const char* name, S32& value );
  174. BOOL getAttributeF32(const char* name, F32& value );
  175. BOOL getAttributeF64(const char* name, F64& value );
  176. BOOL getAttributeColor(const char* name, LLColor4& value );
  177. BOOL getAttributeColor4(const char* name, LLColor4& value );
  178. BOOL getAttributeColor4U(const char* name, LLColor4U& value );
  179. BOOL getAttributeVector3(const char* name, LLVector3& value );
  180. BOOL getAttributeVector3d(const char* name, LLVector3d& value );
  181. BOOL getAttributeQuat(const char* name, LLQuaternion& value );
  182. BOOL getAttributeUUID(const char* name, LLUUID& value );
  183. BOOL getAttributeString(const char* name, std::string& value );
  184.     const ValueType& getType() const { return mType; }
  185.     U32 getLength() const { return mLength; }
  186.     U32 getPrecision() const { return mPrecision; }
  187.     const std::string& getValue() const { return mValue; }
  188. std::string getSanitizedValue() const;
  189. std::string getTextContents() const;
  190.     const LLStringTableEntry* getName() const { return mName; }
  191. BOOL hasName(const char* name) const { return mName == gStringTable.checkStringEntry(name); }
  192. BOOL hasName(const std::string& name) const { return mName == gStringTable.checkStringEntry(name.c_str()); }
  193.     const std::string& getID() const { return mID; }
  194.     U32 getChildCount() const;
  195.     // getChild returns a Null LLXMLNode (not a NULL pointer) if there is no such child.
  196.     // This child has no value so any getTYPEValue() calls on it will return 0.
  197.     bool getChild(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
  198.     bool getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
  199.     void getChildren(const char* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;
  200.     void getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;
  201. // recursively finds all children at any level matching name
  202. void getDescendants(const LLStringTableEntry* name, LLXMLNodeList &children) const;
  203. bool getAttribute(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
  204. bool getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
  205. S32 getLineNumber();
  206. // The following skip over attributes
  207. LLXMLNodePtr getFirstChild() const;
  208. LLXMLNodePtr getNextSibling() const;
  209.     LLXMLNodePtr getRoot();
  210. // Setters
  211. bool setAttributeString(const char* attr, const std::string& value);
  212. void setBoolValue(const BOOL value) { setBoolValue(1, &value); }
  213. void setByteValue(const U8 value, Encoding encoding = ENCODING_DEFAULT) { setByteValue(1, &value, encoding); }
  214. void setIntValue(const S32 value, Encoding encoding = ENCODING_DEFAULT) { setIntValue(1, &value, encoding); }
  215. void setUnsignedValue(const U32 value, Encoding encoding = ENCODING_DEFAULT) { setUnsignedValue(1, &value, encoding); }
  216. void setLongValue(const U64 value, Encoding encoding = ENCODING_DEFAULT) { setLongValue(1, &value, encoding); }
  217. void setFloatValue(const F32 value, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0) { setFloatValue(1, &value, encoding); }
  218. void setDoubleValue(const F64 value, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0) { setDoubleValue(1, &value, encoding); }
  219. void setStringValue(const std::string& value) { setStringValue(1, &value); }
  220. void setUUIDValue(const LLUUID value) { setUUIDValue(1, &value); }
  221. void setNodeRefValue(const LLXMLNode *value) { setNodeRefValue(1, &value); }
  222. void setBoolValue(U32 length, const BOOL *array);
  223. void setByteValue(U32 length, const U8 *array, Encoding encoding = ENCODING_DEFAULT);
  224. void setIntValue(U32 length, const S32 *array, Encoding encoding = ENCODING_DEFAULT);
  225. void setUnsignedValue(U32 length, const U32* array, Encoding encoding = ENCODING_DEFAULT);
  226. void setLongValue(U32 length, const U64 *array, Encoding encoding = ENCODING_DEFAULT);
  227. void setFloatValue(U32 length, const F32 *array, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0);
  228. void setDoubleValue(U32 length, const F64 *array, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0);
  229. void setStringValue(U32 length, const std::string *array);
  230. void setUUIDValue(U32 length, const LLUUID *array);
  231. void setNodeRefValue(U32 length, const LLXMLNode **array);
  232. void setValue(const std::string& value);
  233. void setName(const std::string& name);
  234. void setName(LLStringTableEntry* name);
  235. void setLineNumber(S32 line_number);
  236. // Escapes " (quot) ' (apos) & (amp) < (lt) > (gt)
  237. static std::string escapeXML(const std::string& xml);
  238. // Set the default node corresponding to this default node
  239. void setDefault(LLXMLNode *default_node);
  240. // Find the node within defaults_list which corresponds to this node
  241. void findDefault(LLXMLNode *defaults_list);
  242. void updateDefault();
  243. // Delete any child nodes that aren't among the tree's children, recursive
  244. void scrubToTree(LLXMLNode *tree);
  245. BOOL deleteChildren(const std::string& name);
  246. BOOL deleteChildren(LLStringTableEntry* name);
  247. void setAttributes(ValueType type, U32 precision, Encoding encoding, U32 length);
  248. //  void appendValue(const std::string& value); // Unused
  249. // Unit Testing
  250. void createUnitTest(S32 max_num_children);
  251. BOOL performUnitTest(std::string &error_buffer);
  252. protected:
  253. BOOL removeChild(LLXMLNode* child);
  254. public:
  255. std::string mID; // The ID attribute of this node
  256. XML_Parser *mParser; // Temporary pointer while loading
  257. BOOL mIsAttribute; // Flag is only used for output formatting
  258. U32 mVersionMajor; // Version of this tag to use
  259. U32 mVersionMinor;
  260. U32 mLength; // If the length is nonzero, then only return arrays of this length
  261. U32 mPrecision; // The number of BITS per array item
  262. ValueType mType; // The value type
  263. Encoding mEncoding; // The value encoding
  264. S32 mLineNumber; // line number in source file, if applicable
  265. LLXMLNode* mParent; // The parent node
  266. LLXMLChildrenPtr mChildren; // The child nodes
  267. LLXMLAttribList mAttributes; // The attribute nodes
  268. LLXMLNodePtr mPrev; // Double-linked list previous node
  269. LLXMLNodePtr mNext; // Double-linked list next node
  270. static BOOL sStripEscapedStrings;
  271. static BOOL sStripWhitespaceValues;
  272. protected:
  273. LLStringTableEntry *mName; // The name of this node
  274. // The value of this node (use getters/setters only)
  275. // Values are not XML-escaped in memory
  276. // They may contain " (quot) ' (apos) & (amp) < (lt) > (gt)
  277. std::string mValue;
  278. LLXMLNodePtr mDefault; // Mirror node in the default tree
  279. static const char *skipWhitespace(const char *str);
  280. static const char *skipNonWhitespace(const char *str);
  281. static const char *parseInteger(const char *str, U64 *dest, BOOL *is_negative, U32 precision, Encoding encoding);
  282. static const char *parseFloat(const char *str, F64 *dest, U32 precision, Encoding encoding);
  283. BOOL isFullyDefault();
  284. };
  285. #endif // LL_LLXMLNODE