summaryrefslogtreecommitdiff
path: root/indra/llxml/llxmlnode.h
blob: 62ab51fa8c7c9d363ab6ec17435d12742136bade (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
/**
 * @file llxmlnode.h
 * @brief LLXMLNode definition
 *
 * $LicenseInfo:firstyear=2000&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLXMLNODE_H
#define LL_LLXMLNODE_H

#ifndef XML_STATIC
#define XML_STATIC
#endif
#ifdef LL_USESYSTEMLIBS
#include <expat.h>
#else
#include "expat/expat.h"
#endif
#include <map>

#include "indra_constants.h"
#include "llrefcount.h"
#include "llpointer.h"
#include "llstring.h"
#include "llstringtable.h"
#include "llfile.h"
#include "lluuid.h"

class LLVector3;
class LLVector3d;
class LLQuaternion;
class LLColor4;
class LLColor4U;


struct CompareAttributes
{
    bool operator()(const LLStringTableEntry* const lhs, const LLStringTableEntry* const rhs) const
    {
        if (lhs == NULL)
            return TRUE;
        if (rhs == NULL)
            return FALSE;

        return strcmp(lhs->mString, rhs->mString) < 0;
    }
};


// Defines a simple node hierarchy for reading and writing task objects

class LLXMLNode;
typedef LLPointer<LLXMLNode> LLXMLNodePtr;
typedef std::multimap<std::string, LLXMLNodePtr > LLXMLNodeList;
typedef std::multimap<const LLStringTableEntry *, LLXMLNodePtr > LLXMLChildList;
typedef std::map<const LLStringTableEntry *, LLXMLNodePtr, CompareAttributes> LLXMLAttribList;

class LLColor4;
class LLColor4U;
class LLQuaternion;
class LLVector3;
class LLVector3d;
class LLVector4;
class LLVector4U;

struct LLXMLChildren : public LLThreadSafeRefCount
{
    LLXMLChildList map;         // Map of children names->pointers
    LLXMLNodePtr head;          // Head of the double-linked list
    LLXMLNodePtr tail;          // Tail of the double-linked list
};
typedef LLPointer<LLXMLChildren> LLXMLChildrenPtr;

class LLXMLNode : public LLThreadSafeRefCount
{
public:
    enum ValueType
    {
        TYPE_CONTAINER,     // A node which contains nodes
        TYPE_UNKNOWN,       // A node loaded from file without a specified type
        TYPE_BOOLEAN,       // "true" or "false"
        TYPE_INTEGER,       // any integer type: U8, U32, S32, U64, etc.
        TYPE_FLOAT,         // any floating point type: F32, F64
        TYPE_STRING,        // a string
        TYPE_UUID,          // a UUID
        TYPE_NODEREF,       // the ID of another node in the hierarchy to reference
    };

    enum Encoding
    {
        ENCODING_DEFAULT = 0,
        ENCODING_DECIMAL,
        ENCODING_HEX,
        // ENCODING_BASE32, // Not implemented yet
    };

protected:
    ~LLXMLNode();

public:
    LLXMLNode();
    LLXMLNode(const char* name, BOOL is_attribute);
    LLXMLNode(LLStringTableEntry* name, BOOL is_attribute);
    LLXMLNode(const LLXMLNode& rhs);
    LLXMLNodePtr deepCopy();

    BOOL isNull();

    BOOL deleteChild(LLXMLNode* child);
    void addChild(LLXMLNodePtr& new_child);
    void setParent(LLXMLNodePtr& new_parent); // reparent if necessary

    // Serialization
    static bool parseFile(
        const std::string& filename,
        LLXMLNodePtr& node,
        LLXMLNode* defaults_tree);
    static bool parseBuffer(
        U8* buffer,
        U32 length,
        LLXMLNodePtr& node,
        LLXMLNode* defaults);
    static bool parseStream(
        std::istream& str,
        LLXMLNodePtr& node,
        LLXMLNode* defaults);
    static bool updateNode(
        LLXMLNodePtr& node,
        LLXMLNodePtr& update_node);

    static bool getLayeredXMLNode(LLXMLNodePtr& root, const std::vector<std::string>& paths);


    // Write standard XML file header:
    // <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
    static void writeHeaderToFile(LLFILE *out_file);

    // Write XML to file with one attribute per line.
    // XML escapes values as they are written.
    void writeToFile(LLFILE *out_file, const std::string& indent = std::string(), bool use_type_decorations=true);
    void writeToOstream(std::ostream& output_stream, const std::string& indent = std::string(), bool use_type_decorations=true);

    // Utility
    void findName(const std::string& name, LLXMLNodeList &results);
    void findName(LLStringTableEntry* name, LLXMLNodeList &results);
    void findID(const std::string& id, LLXMLNodeList &results);


    virtual LLXMLNodePtr createChild(const char* name, BOOL is_attribute);
    virtual LLXMLNodePtr createChild(LLStringTableEntry* name, BOOL is_attribute);


    // Getters
    U32 getBoolValue(U32 expected_length, BOOL *array);
    U32 getByteValue(U32 expected_length, U8 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getIntValue(U32 expected_length, S32 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getUnsignedValue(U32 expected_length, U32 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getLongValue(U32 expected_length, U64 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getFloatValue(U32 expected_length, F32 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getDoubleValue(U32 expected_length, F64 *array, Encoding encoding = ENCODING_DEFAULT);
    U32 getStringValue(U32 expected_length, std::string *array);
    U32 getUUIDValue(U32 expected_length, LLUUID *array);
    U32 getNodeRefValue(U32 expected_length, LLXMLNode **array);

    BOOL hasAttribute(const char* name );

        // these are designed to be more generic versions of the functions
    // rather than relying on LL-types
    bool getAttribute_bool(const char* name, bool& value );

    BOOL getAttributeBOOL(const char* name, BOOL& value );
    BOOL getAttributeU8(const char* name, U8& value );
    BOOL getAttributeS8(const char* name, S8& value );
    BOOL getAttributeU16(const char* name, U16& value );
    BOOL getAttributeS16(const char* name, S16& value );
    BOOL getAttributeU32(const char* name, U32& value );
    BOOL getAttributeS32(const char* name, S32& value );
    BOOL getAttributeF32(const char* name, F32& value );
    BOOL getAttributeF64(const char* name, F64& value );
    BOOL getAttributeColor(const char* name, LLColor4& value );
    BOOL getAttributeColor4(const char* name, LLColor4& value );
    BOOL getAttributeColor4U(const char* name, LLColor4U& value );
    BOOL getAttributeVector3(const char* name, LLVector3& value );
    BOOL getAttributeVector3d(const char* name, LLVector3d& value );
    BOOL getAttributeQuat(const char* name, LLQuaternion& value );
    BOOL getAttributeUUID(const char* name, LLUUID& value );
    BOOL getAttributeString(const char* name, std::string& value );

    const ValueType& getType() const { return mType; }
    U32 getLength() const { return mLength; }
    U32 getPrecision() const { return mPrecision; }
    const std::string& getValue() const { return mValue; }
    std::string getSanitizedValue() const;
    std::string getTextContents() const;
    const LLStringTableEntry* getName() const { return mName; }
    BOOL hasName(const char* name) const { return mName == gStringTable.checkStringEntry(name); }
    BOOL hasName(const std::string& name) const { return mName == gStringTable.checkStringEntry(name.c_str()); }
    const std::string& getID() const { return mID; }

    U32 getChildCount() const;
    // getChild returns a Null LLXMLNode (not a NULL pointer) if there is no such child.
    // This child has no value so any getTYPEValue() calls on it will return 0.
    bool getChild(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
    bool getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
    void getChildren(const char* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;
    void getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;

    // recursively finds all children at any level matching name
    void getDescendants(const LLStringTableEntry* name, LLXMLNodeList &children) const;

    bool getAttribute(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
    bool getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);

    S32 getLineNumber();

    // The following skip over attributes
    LLXMLNodePtr getFirstChild() const;
    LLXMLNodePtr getNextSibling() const;

    LLXMLNodePtr getRoot();

    // Setters

    bool setAttributeString(const char* attr, const std::string& value);

    void setBoolValue(const BOOL value) { setBoolValue(1, &value); }
    void setByteValue(const U8 value, Encoding encoding = ENCODING_DEFAULT) { setByteValue(1, &value, encoding); }
    void setIntValue(const S32 value, Encoding encoding = ENCODING_DEFAULT) { setIntValue(1, &value, encoding); }
    void setUnsignedValue(const U32 value, Encoding encoding = ENCODING_DEFAULT) { setUnsignedValue(1, &value, encoding); }
    void setLongValue(const U64 value, Encoding encoding = ENCODING_DEFAULT) { setLongValue(1, &value, encoding); }
    void setFloatValue(const F32 value, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0) { setFloatValue(1, &value, encoding); }
    void setDoubleValue(const F64 value, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0) { setDoubleValue(1, &value, encoding); }
    void setStringValue(const std::string& value) { setStringValue(1, &value); }
    void setUUIDValue(const LLUUID value) { setUUIDValue(1, &value); }
    void setNodeRefValue(const LLXMLNode *value) { setNodeRefValue(1, &value); }

    void setBoolValue(U32 length, const BOOL *array);
    void setByteValue(U32 length, const U8 *array, Encoding encoding = ENCODING_DEFAULT);
    void setIntValue(U32 length, const S32 *array, Encoding encoding = ENCODING_DEFAULT);
    void setUnsignedValue(U32 length, const U32* array, Encoding encoding = ENCODING_DEFAULT);
    void setLongValue(U32 length, const U64 *array, Encoding encoding = ENCODING_DEFAULT);
    void setFloatValue(U32 length, const F32 *array, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0);
    void setDoubleValue(U32 length, const F64 *array, Encoding encoding = ENCODING_DEFAULT, U32 precision = 0);
    void setStringValue(U32 length, const std::string *array);
    void setUUIDValue(U32 length, const LLUUID *array);
    void setNodeRefValue(U32 length, const LLXMLNode **array);
    void setValue(const std::string& value);
    void setName(const std::string& name);
    void setName(LLStringTableEntry* name);

    void setLineNumber(S32 line_number);

    // Escapes " (quot) ' (apos) & (amp) < (lt) > (gt)
    static std::string escapeXML(const std::string& xml);

    // Set the default node corresponding to this default node
    void setDefault(LLXMLNode *default_node);

    // Find the node within defaults_list which corresponds to this node
    void findDefault(LLXMLNode *defaults_list);

    void updateDefault();

    // Delete any child nodes that aren't among the tree's children, recursive
    void scrubToTree(LLXMLNode *tree);

    BOOL deleteChildren(const std::string& name);
    BOOL deleteChildren(LLStringTableEntry* name);
    void setAttributes(ValueType type, U32 precision, Encoding encoding, U32 length);
//  void appendValue(const std::string& value); // Unused

    // Unit Testing
    void createUnitTest(S32 max_num_children);
    BOOL performUnitTest(std::string &error_buffer);

protected:
    BOOL removeChild(LLXMLNode* child);

public:
    std::string mID;                // The ID attribute of this node

    XML_Parser *mParser;        // Temporary pointer while loading

    BOOL mIsAttribute;          // Flag is only used for output formatting
    U32 mVersionMajor;          // Version of this tag to use
    U32 mVersionMinor;
    U32 mLength;                // If the length is nonzero, then only return arrays of this length
    U32 mPrecision;             // The number of BITS per array item
    ValueType mType;            // The value type
    Encoding mEncoding;         // The value encoding
    S32 mLineNumber;            // line number in source file, if applicable

    LLXMLNode* mParent;             // The parent node
    LLXMLChildrenPtr mChildren;     // The child nodes
    LLXMLAttribList mAttributes;        // The attribute nodes
    LLXMLNodePtr mPrev;             // Double-linked list previous node
    LLXMLNodePtr mNext;             // Double-linked list next node

    static BOOL sStripEscapedStrings;
    static BOOL sStripWhitespaceValues;

protected:
    LLStringTableEntry *mName;      // The name of this node

    // The value of this node (use getters/setters only)
    // Values are not XML-escaped in memory
    // They may contain " (quot) ' (apos) & (amp) < (lt) > (gt)
    std::string mValue;

    LLXMLNodePtr mDefault;      // Mirror node in the default tree

    static const char *skipWhitespace(const char *str);
    static const char *skipNonWhitespace(const char *str);
    static const char *parseInteger(const char *str, U64 *dest, BOOL *is_negative, U32 precision, Encoding encoding);
    static const char *parseFloat(const char *str, F64 *dest, U32 precision, Encoding encoding);

    BOOL isFullyDefault();
};

#endif // LL_LLXMLNODE