xmlParser.h (10152:52c552138ba1) xmlParser.h (10234:5cb711fa6176)
1/****************************************************************************/
2/*! \mainpage XMLParser library
3 * \section intro_sec Introduction
4 *
5 * This is a basic XML parser written in ANSI C++ for portability.
6 * It works by using recursion and a node tree for breaking
7 * down the elements of an XML document.
8 *

--- 28 unchanged lines hidden (view full) ---

37 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
39 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
40 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
42 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 *
44 * Copyright (c) 2002, Business-Insight
1/****************************************************************************/
2/*! \mainpage XMLParser library
3 * \section intro_sec Introduction
4 *
5 * This is a basic XML parser written in ANSI C++ for portability.
6 * It works by using recursion and a node tree for breaking
7 * down the elements of an XML document.
8 *

--- 28 unchanged lines hidden (view full) ---

37 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
39 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
40 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
42 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 *
44 * Copyright (c) 2002, Business-Insight
45 * Copyright (c) 2010-2013 Advanced Micro Devices, Inc.
45 * <a href="http://www.Business-Insight.com">Business-Insight</a>
46 * All rights reserved.
47 *
48 * \section tutorial First Tutorial
49 * You can follow a simple <a href="../../xmlParser.html">Tutorial</a> to know the basics...
50 *
51 * \section usage General usage: How to include the XMLParser library inside your project.
52 *

--- 102 unchanged lines hidden (view full) ---

155#endif
156
157#ifdef _XMLWINDOWS
158#include <tchar.h>
159#else
160#define XMLDLLENTRY
161#ifndef XML_NO_WIDE_CHAR
162#include <wchar.h> // to have 'wcsrtombs' for ANSI version
46 * <a href="http://www.Business-Insight.com">Business-Insight</a>
47 * All rights reserved.
48 *
49 * \section tutorial First Tutorial
50 * You can follow a simple <a href="../../xmlParser.html">Tutorial</a> to know the basics...
51 *
52 * \section usage General usage: How to include the XMLParser library inside your project.
53 *

--- 102 unchanged lines hidden (view full) ---

156#endif
157
158#ifdef _XMLWINDOWS
159#include <tchar.h>
160#else
161#define XMLDLLENTRY
162#ifndef XML_NO_WIDE_CHAR
163#include <wchar.h> // to have 'wcsrtombs' for ANSI version
163 // to have 'mbsrtowcs' for WIDECHAR version
164// to have 'mbsrtowcs' for WIDECHAR version
164#endif
165#endif
166
167// Some common types for char set portable code
168#ifdef _XMLWIDECHAR
165#endif
166#endif
167
168// Some common types for char set portable code
169#ifdef _XMLWIDECHAR
169 #define _CXML(c) L ## c
170 #define XMLCSTR const wchar_t *
171 #define XMLSTR wchar_t *
172 #define XMLCHAR wchar_t
170#define _CXML(c) L ## c
171#define XMLCSTR const wchar_t *
172#define XMLSTR wchar_t *
173#define XMLCHAR wchar_t
173#else
174#else
174 #define _CXML(c) c
175 #define XMLCSTR const char *
176 #define XMLSTR char *
177 #define XMLCHAR char
175#define _CXML(c) c
176#define XMLCSTR const char *
177#define XMLSTR char *
178#define XMLCHAR char
178#endif
179#ifndef FALSE
179#endif
180#ifndef FALSE
180 #define FALSE 0
181#define FALSE 0
181#endif /* FALSE */
182#ifndef TRUE
182#endif /* FALSE */
183#ifndef TRUE
183 #define TRUE 1
184#define TRUE 1
184#endif /* TRUE */
185
186
187/// Enumeration for XML parse errors.
185#endif /* TRUE */
186
187
188/// Enumeration for XML parse errors.
188typedef enum XMLError
189{
189typedef enum XMLError {
190 eXMLErrorNone = 0,
191 eXMLErrorMissingEndTag,
192 eXMLErrorNoXMLTagFound,
193 eXMLErrorEmpty,
194 eXMLErrorMissingTagName,
195 eXMLErrorMissingEndTagName,
196 eXMLErrorUnmatchedEndTag,
197 eXMLErrorUnmatchedEndClearTag,

--- 10 unchanged lines hidden (view full) ---

208 eXMLErrorBase64DataSizeIsNotMultipleOf4,
209 eXMLErrorBase64DecodeIllegalCharacter,
210 eXMLErrorBase64DecodeTruncatedData,
211 eXMLErrorBase64DecodeBufferTooSmall
212} XMLError;
213
214
215/// Enumeration used to manage type of data. Use in conjunction with structure XMLNodeContents
190 eXMLErrorNone = 0,
191 eXMLErrorMissingEndTag,
192 eXMLErrorNoXMLTagFound,
193 eXMLErrorEmpty,
194 eXMLErrorMissingTagName,
195 eXMLErrorMissingEndTagName,
196 eXMLErrorUnmatchedEndTag,
197 eXMLErrorUnmatchedEndClearTag,

--- 10 unchanged lines hidden (view full) ---

208 eXMLErrorBase64DataSizeIsNotMultipleOf4,
209 eXMLErrorBase64DecodeIllegalCharacter,
210 eXMLErrorBase64DecodeTruncatedData,
211 eXMLErrorBase64DecodeBufferTooSmall
212} XMLError;
213
214
215/// Enumeration used to manage type of data. Use in conjunction with structure XMLNodeContents
216typedef enum XMLElementType
217{
218 eNodeChild=0,
219 eNodeAttribute=1,
220 eNodeText=2,
221 eNodeClear=3,
222 eNodeNULL=4
216typedef enum XMLElementType {
217 eNodeChild = 0,
218 eNodeAttribute = 1,
219 eNodeText = 2,
220 eNodeClear = 3,
221 eNodeNULL = 4
223} XMLElementType;
224
225/// Structure used to obtain error details if the parse fails.
222} XMLElementType;
223
224/// Structure used to obtain error details if the parse fails.
226typedef struct XMLResults
227{
225typedef struct XMLResults {
228 enum XMLError error;
226 enum XMLError error;
229 int nLine,nColumn;
227 int nLine;
228 int nColumn;
230} XMLResults;
231
232/// Structure for XML clear (unformatted) node (usually comments)
233typedef struct XMLClear {
229} XMLResults;
230
231/// Structure for XML clear (unformatted) node (usually comments)
232typedef struct XMLClear {
234 XMLCSTR lpszValue; XMLCSTR lpszOpenTag; XMLCSTR lpszCloseTag;
233 XMLCSTR lpszValue;
234 XMLCSTR lpszOpenTag;
235 XMLCSTR lpszCloseTag;
235} XMLClear;
236
237/// Structure for XML attribute.
238typedef struct XMLAttribute {
236} XMLClear;
237
238/// Structure for XML attribute.
239typedef struct XMLAttribute {
239 XMLCSTR lpszName; XMLCSTR lpszValue;
240 XMLCSTR lpszName;
241 XMLCSTR lpszValue;
240} XMLAttribute;
241
242/// XMLElementPosition are not interchangeable with simple indexes
243typedef int XMLElementPosition;
244
245struct XMLNodeContents;
246
247/** @defgroup XMLParserGeneral The XML parser */
248
249/// Main Class representing a XML node
250/**
251 * All operations are performed using this class.
252 * \note The constructors of the XMLNode class are protected, so use instead one of these four methods to get your first instance of XMLNode:
253 * <ul>
254 * <li> XMLNode::parseString </li>
255 * <li> XMLNode::parseFile </li>
256 * <li> XMLNode::openFileHelper </li>
257 * <li> XMLNode::createXMLTopNode (or XMLNode::createXMLTopNode_WOSD)</li>
258 * </ul> */
242} XMLAttribute;
243
244/// XMLElementPosition are not interchangeable with simple indexes
245typedef int XMLElementPosition;
246
247struct XMLNodeContents;
248
249/** @defgroup XMLParserGeneral The XML parser */
250
251/// Main Class representing a XML node
252/**
253 * All operations are performed using this class.
254 * \note The constructors of the XMLNode class are protected, so use instead one of these four methods to get your first instance of XMLNode:
255 * <ul>
256 * <li> XMLNode::parseString </li>
257 * <li> XMLNode::parseFile </li>
258 * <li> XMLNode::openFileHelper </li>
259 * <li> XMLNode::createXMLTopNode (or XMLNode::createXMLTopNode_WOSD)</li>
260 * </ul> */
259typedef struct XMLDLLENTRY XMLNode
260{
261 private:
261typedef struct XMLDLLENTRY XMLNode {
262private:
262
263 struct XMLNodeDataTag;
264
265 /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode
266 XMLNode(struct XMLNodeDataTag *pParent, XMLSTR lpszName, char isDeclaration);
267 /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode
268 XMLNode(struct XMLNodeDataTag *p);
269
263
264 struct XMLNodeDataTag;
265
266 /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode
267 XMLNode(struct XMLNodeDataTag *pParent, XMLSTR lpszName, char isDeclaration);
268 /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode
269 XMLNode(struct XMLNodeDataTag *p);
270
270 public:
271public:
271 static XMLCSTR getVersion();///< Return the XMLParser library version number
272
273 /** @defgroup conversions Parsing XML files/strings to an XMLNode structure and Rendering XMLNode's to files/string.
274 * @ingroup XMLParserGeneral
275 * @{ */
276
277 /// Parse an XML string and return the root of a XMLNode tree representing the string.
272 static XMLCSTR getVersion();///< Return the XMLParser library version number
273
274 /** @defgroup conversions Parsing XML files/strings to an XMLNode structure and Rendering XMLNode's to files/string.
275 * @ingroup XMLParserGeneral
276 * @{ */
277
278 /// Parse an XML string and return the root of a XMLNode tree representing the string.
278 static XMLNode parseString (XMLCSTR lpXMLString, XMLCSTR tag=NULL, XMLResults *pResults=NULL);
279 static XMLNode parseString(XMLCSTR lpXMLString, XMLCSTR tag = NULL,
280 XMLResults *pResults = NULL);
279 /**< The "parseString" function parse an XML string and return the root of a XMLNode tree. The "opposite" of this function is
280 * the function "createXMLString" that re-creates an XML string from an XMLNode tree. If the XML document is corrupted, the
281 * "parseString" method will initialize the "pResults" variable with some information that can be used to trace the error.
282 * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the
283 * beginning of the "xmlParser.cpp" file.
284 *
285 * @param lpXMLString the XML string to parse
286 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
287 * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function.
288 */
289
290 /// Parse an XML file and return the root of a XMLNode tree representing the file.
281 /**< The "parseString" function parse an XML string and return the root of a XMLNode tree. The "opposite" of this function is
282 * the function "createXMLString" that re-creates an XML string from an XMLNode tree. If the XML document is corrupted, the
283 * "parseString" method will initialize the "pResults" variable with some information that can be used to trace the error.
284 * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the
285 * beginning of the "xmlParser.cpp" file.
286 *
287 * @param lpXMLString the XML string to parse
288 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
289 * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function.
290 */
291
292 /// Parse an XML file and return the root of a XMLNode tree representing the file.
291 static XMLNode parseFile (XMLCSTR filename, XMLCSTR tag=NULL, XMLResults *pResults=NULL);
293 static XMLNode parseFile(XMLCSTR filename, XMLCSTR tag = NULL,
294 XMLResults *pResults = NULL);
292 /**< The "parseFile" function parse an XML file and return the root of a XMLNode tree. The "opposite" of this function is
293 * the function "writeToFile" that re-creates an XML file from an XMLNode tree. If the XML document is corrupted, the
294 * "parseFile" method will initialize the "pResults" variable with some information that can be used to trace the error.
295 * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the
296 * beginning of the "xmlParser.cpp" file.
297 *
298 * @param filename the path to the XML file to parse
299 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
300 * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function.
301 */
302
303 /// Parse an XML file and return the root of a XMLNode tree representing the file. A very crude error checking is made. An attempt to guess the Char Encoding used in the file is made.
295 /**< The "parseFile" function parse an XML file and return the root of a XMLNode tree. The "opposite" of this function is
296 * the function "writeToFile" that re-creates an XML file from an XMLNode tree. If the XML document is corrupted, the
297 * "parseFile" method will initialize the "pResults" variable with some information that can be used to trace the error.
298 * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the
299 * beginning of the "xmlParser.cpp" file.
300 *
301 * @param filename the path to the XML file to parse
302 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
303 * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function.
304 */
305
306 /// Parse an XML file and return the root of a XMLNode tree representing the file. A very crude error checking is made. An attempt to guess the Char Encoding used in the file is made.
304 static XMLNode openFileHelper(XMLCSTR filename, XMLCSTR tag=NULL);
307 static XMLNode openFileHelper(XMLCSTR filename, XMLCSTR tag = NULL);
305 /**< The "openFileHelper" function reports to the screen all the warnings and errors that occurred during parsing of the XML file.
306 * This function also tries to guess char Encoding (UTF-8, ASCII or SHIT-JIS) based on the first 200 bytes of the file. Since each
307 * application has its own way to report and deal with errors, you should rather use the "parseFile" function to parse XML files
308 * and program yourself thereafter an "error reporting" tailored for your needs (instead of using the very crude "error reporting"
309 * mechanism included inside the "openFileHelper" function).
310 *
311 * If the XML document is corrupted, the "openFileHelper" method will:
312 * - display an error message on the console (or inside a messageBox for windows).

--- 4 unchanged lines hidden (view full) ---

317 *
318 * @param filename the path of the XML file to parse.
319 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
320 */
321
322 static XMLCSTR getError(XMLError error); ///< this gives you a user-friendly explanation of the parsing error
323
324 /// Create an XML string starting from the current XMLNode.
308 /**< The "openFileHelper" function reports to the screen all the warnings and errors that occurred during parsing of the XML file.
309 * This function also tries to guess char Encoding (UTF-8, ASCII or SHIT-JIS) based on the first 200 bytes of the file. Since each
310 * application has its own way to report and deal with errors, you should rather use the "parseFile" function to parse XML files
311 * and program yourself thereafter an "error reporting" tailored for your needs (instead of using the very crude "error reporting"
312 * mechanism included inside the "openFileHelper" function).
313 *
314 * If the XML document is corrupted, the "openFileHelper" method will:
315 * - display an error message on the console (or inside a messageBox for windows).

--- 4 unchanged lines hidden (view full) ---

320 *
321 * @param filename the path of the XML file to parse.
322 * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (<? ... ?>).
323 */
324
325 static XMLCSTR getError(XMLError error); ///< this gives you a user-friendly explanation of the parsing error
326
327 /// Create an XML string starting from the current XMLNode.
325 XMLSTR createXMLString(int nFormat=1, int *pnSize=NULL) const;
328 XMLSTR createXMLString(int nFormat = 1, int *pnSize = NULL) const;
326 /**< The returned string should be free'd using the "freeXMLString" function.
327 *
328 * If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element
329 * with appropriate white spaces and carriage returns. if pnSize is given it returns the size in character of the string. */
330
331 /// Save the content of an xmlNode inside a file
332 XMLError writeToFile(XMLCSTR filename,
329 /**< The returned string should be free'd using the "freeXMLString" function.
330 *
331 * If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element
332 * with appropriate white spaces and carriage returns. if pnSize is given it returns the size in character of the string. */
333
334 /// Save the content of an xmlNode inside a file
335 XMLError writeToFile(XMLCSTR filename,
333 const char *encoding=NULL,
334 char nFormat=1) const;
336 const char *encoding = NULL,
337 char nFormat = 1) const;
335 /**< If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element with appropriate white spaces and carriage returns.
336 * If the global parameter "characterEncoding==encoding_UTF8", then the "encoding" parameter is ignored and always set to "utf-8".
337 * If the global parameter "characterEncoding==encoding_ShiftJIS", then the "encoding" parameter is ignored and always set to "SHIFT-JIS".
338 * If "_XMLWIDECHAR=1", then the "encoding" parameter is ignored and always set to "utf-16".
339 * If no "encoding" parameter is given the "ISO-8859-1" encoding is used. */
340 /** @} */
341
342 /** @defgroup navigate Navigate the XMLNode structure
343 * @ingroup XMLParserGeneral
344 * @{ */
345 XMLCSTR getName() const; ///< name of the node
346 XMLCSTR getText(int i=0) const; ///< return ith text field
347 int nText() const; ///< nbr of text field
348 XMLNode getParentNode() const; ///< return the parent node
349 XMLNode getChildNode(int i=0) const; ///< return ith child node
350 XMLNode getChildNode(XMLCSTR name, int i) const; ///< return ith child node with specific name (return an empty node if failing). If i==-1, this returns the last XMLNode with the given name.
351 XMLNode getChildNode(XMLCSTR name, int *i=NULL) const; ///< return next child node with specific name (return an empty node if failing)
338 /**< If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element with appropriate white spaces and carriage returns.
339 * If the global parameter "characterEncoding==encoding_UTF8", then the "encoding" parameter is ignored and always set to "utf-8".
340 * If the global parameter "characterEncoding==encoding_ShiftJIS", then the "encoding" parameter is ignored and always set to "SHIFT-JIS".
341 * If "_XMLWIDECHAR=1", then the "encoding" parameter is ignored and always set to "utf-16".
342 * If no "encoding" parameter is given the "ISO-8859-1" encoding is used. */
343 /** @} */
344
345 /** @defgroup navigate Navigate the XMLNode structure
346 * @ingroup XMLParserGeneral
347 * @{ */
348 XMLCSTR getName() const; ///< name of the node
349 XMLCSTR getText(int i=0) const; ///< return ith text field
350 int nText() const; ///< nbr of text field
351 XMLNode getParentNode() const; ///< return the parent node
352 XMLNode getChildNode(int i=0) const; ///< return ith child node
353 XMLNode getChildNode(XMLCSTR name, int i) const; ///< return ith child node with specific name (return an empty node if failing). If i==-1, this returns the last XMLNode with the given name.
354 XMLNode getChildNode(XMLCSTR name, int *i=NULL) const; ///< return next child node with specific name (return an empty node if failing)
355 XMLNode* getChildNodePtr(XMLCSTR name, int *j) const;
352 XMLNode getChildNodeWithAttribute(XMLCSTR tagName,
353 XMLCSTR attributeName,
354 XMLCSTR attributeValue=NULL,
355 int *i=NULL) const; ///< return child node with specific name/attribute (return an empty node if failing)
356 XMLNode getChildNodeByPath(XMLCSTR path, char createNodeIfMissing=0, XMLCHAR sep='/');
356 XMLNode getChildNodeWithAttribute(XMLCSTR tagName,
357 XMLCSTR attributeName,
358 XMLCSTR attributeValue=NULL,
359 int *i=NULL) const; ///< return child node with specific name/attribute (return an empty node if failing)
360 XMLNode getChildNodeByPath(XMLCSTR path, char createNodeIfMissing=0, XMLCHAR sep='/');
357 ///< return the first child node with specific path
361 ///< return the first child node with specific path
358 XMLNode getChildNodeByPathNonConst(XMLSTR path, char createNodeIfMissing=0, XMLCHAR sep='/');
362 XMLNode getChildNodeByPathNonConst(XMLSTR path, char createNodeIfMissing=0, XMLCHAR sep='/');
359 ///< return the first child node with specific path.
363 ///< return the first child node with specific path.
360
361 int nChildNode(XMLCSTR name) const; ///< return the number of child node with specific name
362 int nChildNode() const; ///< nbr of child node
363 XMLAttribute getAttribute(int i=0) const; ///< return ith attribute
364 XMLCSTR getAttributeName(int i=0) const; ///< return ith attribute name
365 XMLCSTR getAttributeValue(int i=0) const; ///< return ith attribute value
366 char isAttributeSet(XMLCSTR name) const; ///< test if an attribute with a specific name is given
367 XMLCSTR getAttribute(XMLCSTR name, int i) const; ///< return ith attribute content with specific name (return a NULL if failing)

--- 45 unchanged lines hidden (view full) ---

413
414 /** @defgroup xmlUpdate Updating Nodes
415 * @ingroup xmlModify
416 * Some update functions:
417 * @{
418 */
419 XMLCSTR updateName(XMLCSTR lpszName); ///< change node's name
420 XMLAttribute *updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added
364
365 int nChildNode(XMLCSTR name) const; ///< return the number of child node with specific name
366 int nChildNode() const; ///< nbr of child node
367 XMLAttribute getAttribute(int i=0) const; ///< return ith attribute
368 XMLCSTR getAttributeName(int i=0) const; ///< return ith attribute name
369 XMLCSTR getAttributeValue(int i=0) const; ///< return ith attribute value
370 char isAttributeSet(XMLCSTR name) const; ///< test if an attribute with a specific name is given
371 XMLCSTR getAttribute(XMLCSTR name, int i) const; ///< return ith attribute content with specific name (return a NULL if failing)

--- 45 unchanged lines hidden (view full) ---

417
418 /** @defgroup xmlUpdate Updating Nodes
419 * @ingroup xmlModify
420 * Some update functions:
421 * @{
422 */
423 XMLCSTR updateName(XMLCSTR lpszName); ///< change node's name
424 XMLAttribute *updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added
421 XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName=NULL,int i=0); ///< if the attribute to update is missing, a new one will be added
422 XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName);///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added
425 XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName=NULL, int i=0); ///< if the attribute to update is missing, a new one will be added
426 XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName, XMLCSTR lpszOldName);///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added
423 XMLCSTR updateText(XMLCSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added
424 XMLCSTR updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added
425 XMLClear *updateClear(XMLCSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added
427 XMLCSTR updateText(XMLCSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added
428 XMLCSTR updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added
429 XMLClear *updateClear(XMLCSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added
426 XMLClear *updateClear(XMLClear *newP,XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added
430 XMLClear *updateClear(XMLClear *newP, XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added
427 XMLClear *updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added
428 /** @} */
429
430 /** @defgroup xmlDelete Deleting Nodes or Attributes
431 * @ingroup xmlModify
432 * Some deletion functions:
433 * @{
434 */

--- 42 unchanged lines hidden (view full) ---

477 static XMLNode createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration=FALSE); ///< Create the top node of an XMLNode structure
478 XMLNode addChild_WOSD(XMLSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1); ///< Add a new child node
479 XMLAttribute *addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValue); ///< Add a new attribute
480 XMLCSTR addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos=-1); ///< Add a new text content
481 XMLClear *addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1); ///< Add a new clear Tag
482
483 XMLCSTR updateName_WOSD(XMLSTR lpszName); ///< change node's name
484 XMLAttribute *updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added
431 XMLClear *updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added
432 /** @} */
433
434 /** @defgroup xmlDelete Deleting Nodes or Attributes
435 * @ingroup xmlModify
436 * Some deletion functions:
437 * @{
438 */

--- 42 unchanged lines hidden (view full) ---

481 static XMLNode createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration=FALSE); ///< Create the top node of an XMLNode structure
482 XMLNode addChild_WOSD(XMLSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1); ///< Add a new child node
483 XMLAttribute *addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValue); ///< Add a new attribute
484 XMLCSTR addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos=-1); ///< Add a new text content
485 XMLClear *addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1); ///< Add a new clear Tag
486
487 XMLCSTR updateName_WOSD(XMLSTR lpszName); ///< change node's name
488 XMLAttribute *updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added
485 XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName=NULL,int i=0); ///< if the attribute to update is missing, a new one will be added
486 XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,XMLCSTR lpszOldName); ///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added
489 XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName=NULL, int i=0); ///< if the attribute to update is missing, a new one will be added
490 XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName, XMLCSTR lpszOldName); ///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added
487 XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added
488 XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added
489 XMLClear *updateClear_WOSD(XMLSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added
491 XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added
492 XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added
493 XMLClear *updateClear_WOSD(XMLSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added
490 XMLClear *updateClear_WOSD(XMLClear *newP,XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added
494 XMLClear *updateClear_WOSD(XMLClear *newP, XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added
491 XMLClear *updateClear_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added
492 /** @} */
493
494 /** @defgroup xmlPosition Position helper functions (use in conjunction with the update&add functions
495 * @ingroup xmlModify
496 * These are some useful functions when you want to insert a childNode, a text or a XMLClearTag in the
497 * middle (at a specified position) of a XMLNode tree already constructed. The value returned by these
498 * methods is to be used as last parameter (parameter 'pos') of addChild, addText or addClear.

--- 4 unchanged lines hidden (view full) ---

503 XMLElementPosition positionOfClear(XMLCSTR lpszValue) const;
504 XMLElementPosition positionOfClear(XMLClear *a) const;
505 XMLElementPosition positionOfChildNode(int i=0) const;
506 XMLElementPosition positionOfChildNode(XMLNode x) const;
507 XMLElementPosition positionOfChildNode(XMLCSTR name, int i=0) const; ///< return the position of the ith childNode with the specified name if (name==NULL) return the position of the ith childNode
508 /** @} */
509
510 /// Enumeration for XML character encoding.
495 XMLClear *updateClear_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added
496 /** @} */
497
498 /** @defgroup xmlPosition Position helper functions (use in conjunction with the update&add functions
499 * @ingroup xmlModify
500 * These are some useful functions when you want to insert a childNode, a text or a XMLClearTag in the
501 * middle (at a specified position) of a XMLNode tree already constructed. The value returned by these
502 * methods is to be used as last parameter (parameter 'pos') of addChild, addText or addClear.

--- 4 unchanged lines hidden (view full) ---

507 XMLElementPosition positionOfClear(XMLCSTR lpszValue) const;
508 XMLElementPosition positionOfClear(XMLClear *a) const;
509 XMLElementPosition positionOfChildNode(int i=0) const;
510 XMLElementPosition positionOfChildNode(XMLNode x) const;
511 XMLElementPosition positionOfChildNode(XMLCSTR name, int i=0) const; ///< return the position of the ith childNode with the specified name if (name==NULL) return the position of the ith childNode
512 /** @} */
513
514 /// Enumeration for XML character encoding.
511 typedef enum XMLCharEncoding
512 {
513 char_encoding_error=0,
514 char_encoding_UTF8=1,
515 char_encoding_legacy=2,
516 char_encoding_ShiftJIS=3,
517 char_encoding_GB2312=4,
518 char_encoding_Big5=5,
519 char_encoding_GBK=6 // this is actually the same as Big5
515 typedef enum XMLCharEncoding {
516 char_encoding_error = 0,
517 char_encoding_UTF8 = 1,
518 char_encoding_legacy = 2,
519 char_encoding_ShiftJIS = 3,
520 char_encoding_GB2312 = 4,
521 char_encoding_Big5 = 5,
522 char_encoding_GBK = 6 // this is actually the same as Big5
520 } XMLCharEncoding;
521
522 /** \addtogroup conversions
523 * @{ */
524
525 /// Sets the global options for the conversions
526 static char setGlobalOptions(XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8, char guessWideCharChars=1,
527 char dropWhiteSpace=1, char removeCommentsInMiddleOfText=1);

--- 56 unchanged lines hidden (view full) ---

584 * file to be parsed. The XMLNode::openFileHelper function is using this function to automatically compute
585 * the value of the "characterEncoding" global parameter. There are several heuristics used to do the
586 * guess. One of the heuristic is based on the "encoding" attribute. The original XML specifications
587 * forbids to use this attribute to do the guess but you can still use it if you set
588 * "useXMLEncodingAttribute" to 1 (this is the default behavior and the behavior of most parsers).
589 * If an inconsistency in the encoding is detected, then the return value is "0". */
590 /** @} */
591
523 } XMLCharEncoding;
524
525 /** \addtogroup conversions
526 * @{ */
527
528 /// Sets the global options for the conversions
529 static char setGlobalOptions(XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8, char guessWideCharChars=1,
530 char dropWhiteSpace=1, char removeCommentsInMiddleOfText=1);

--- 56 unchanged lines hidden (view full) ---

587 * file to be parsed. The XMLNode::openFileHelper function is using this function to automatically compute
588 * the value of the "characterEncoding" global parameter. There are several heuristics used to do the
589 * guess. One of the heuristic is based on the "encoding" attribute. The original XML specifications
590 * forbids to use this attribute to do the guess but you can still use it if you set
591 * "useXMLEncodingAttribute" to 1 (this is the default behavior and the behavior of most parsers).
592 * If an inconsistency in the encoding is detected, then the return value is "0". */
593 /** @} */
594
592 private:
593 // these are functions and structures used internally by the XMLNode class (don't bother about them):
595private:
596 // these are functions and structures used internally by the XMLNode class (don't bother about them):
594
597
595 typedef struct XMLNodeDataTag // to allow shallow copy and "intelligent/smart" pointers (automatic delete):
596 {
597 XMLCSTR lpszName; // Element name (=NULL if root)
598 int nChild, // Number of child nodes
599 nText, // Number of text fields
600 nClear, // Number of Clear fields (comments)
601 nAttribute; // Number of attributes
602 char isDeclaration; // Whether node is an XML declaration - '<?xml ?>'
603 struct XMLNodeDataTag *pParent; // Pointer to parent element (=NULL if root)
604 XMLNode *pChild; // Array of child nodes
605 XMLCSTR *pText; // Array of text fields
606 XMLClear *pClear; // Array of clear fields
607 XMLAttribute *pAttribute; // Array of attributes
608 int *pOrder; // order of the child_nodes,text_fields,clear_fields
609 int ref_count; // for garbage collection (smart pointers)
610 } XMLNodeData;
611 XMLNodeData *d;
598 typedef struct XMLNodeDataTag { // to allow shallow copy and "intelligent/smart" pointers (automatic delete):
599 XMLCSTR lpszName; // Element name (=NULL if root)
600 int nChild, // Number of child nodes
601 nText, // Number of text fields
602 nClear, // Number of Clear fields (comments)
603 nAttribute; // Number of attributes
604 char isDeclaration; // Whether node is an XML declaration - '<?xml ?>'
605 struct XMLNodeDataTag *pParent; // Pointer to parent element (=NULL if root)
606 XMLNode *pChild; // Array of child nodes
607 XMLCSTR *pText; // Array of text fields
608 XMLClear *pClear; // Array of clear fields
609 XMLAttribute *pAttribute; // Array of attributes
610 int *pOrder; // order of the child_nodes,text_fields,clear_fields
611 int ref_count; // for garbage collection (smart pointers)
612 } XMLNodeData;
613 XMLNodeData *d;
612
614
613 char parseClearTag(void *px, void *pa);
614 char maybeAddTxT(void *pa, XMLCSTR tokenPStr);
615 int ParseXMLElement(void *pXML);
616 void *addToOrder(int memInc, int *_pos, int nc, void *p, int size, XMLElementType xtype);
617 int indexText(XMLCSTR lpszValue) const;
618 int indexClear(XMLCSTR lpszValue) const;
619 XMLNode addChild_priv(int,XMLSTR,char,int);
620 XMLAttribute *addAttribute_priv(int,XMLSTR,XMLSTR);
621 XMLCSTR addText_priv(int,XMLSTR,int);
622 XMLClear *addClear_priv(int,XMLSTR,XMLCSTR,XMLCSTR,int);
623 void emptyTheNode(char force);
624 static inline XMLElementPosition findPosition(XMLNodeData *d, int index, XMLElementType xtype);
625 static int CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat);
626 static int removeOrderElement(XMLNodeData *d, XMLElementType t, int index);
627 static void exactMemory(XMLNodeData *d);
628 static int detachFromParent(XMLNodeData *d);
615 char parseClearTag(void *px, void *pa);
616 char maybeAddTxT(void *pa, XMLCSTR tokenPStr);
617 int ParseXMLElement(void *pXML);
618 void *addToOrder(int memInc, int *_pos, int nc, void *p, int size, XMLElementType xtype);
619 int indexText(XMLCSTR lpszValue) const;
620 int indexClear(XMLCSTR lpszValue) const;
621 XMLNode addChild_priv(int, XMLSTR, char, int);
622 XMLAttribute *addAttribute_priv(int, XMLSTR, XMLSTR);
623 XMLCSTR addText_priv(int, XMLSTR, int);
624 XMLClear *addClear_priv(int, XMLSTR, XMLCSTR, XMLCSTR, int);
625 void emptyTheNode(char force);
626 static inline XMLElementPosition findPosition(XMLNodeData *d, int index, XMLElementType xtype);
627 static int CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat);
628 static int removeOrderElement(XMLNodeData *d, XMLElementType t, int index);
629 static void exactMemory(XMLNodeData *d);
630 static int detachFromParent(XMLNodeData *d);
629} XMLNode;
630
631/// This structure is given by the function XMLNode::enumContents.
631} XMLNode;
632
633/// This structure is given by the function XMLNode::enumContents.
632typedef struct XMLNodeContents
633{
634typedef struct XMLNodeContents {
634 /// This dictates what's the content of the XMLNodeContent
635 enum XMLElementType etype;
636 /**< should be an union to access the appropriate data. Compiler does not allow union of object with constructor... too bad. */
637 XMLNode child;
638 XMLAttribute attrib;
639 XMLCSTR text;
640 XMLClear clear;
641

--- 17 unchanged lines hidden (view full) ---

659 * @ingroup XMLParserGeneral
660 * The "xmlto?" functions are equivalents to the atoi, atol, atof functions.
661 * The only difference is: If the variable "xmlString" is NULL, than the return value
662 * is "defautValue". These 6 functions are only here as "convenience" functions for the
663 * user (they are not used inside the XMLparser). If you don't need them, you can
664 * delete them without any trouble.
665 *
666 * @{ */
635 /// This dictates what's the content of the XMLNodeContent
636 enum XMLElementType etype;
637 /**< should be an union to access the appropriate data. Compiler does not allow union of object with constructor... too bad. */
638 XMLNode child;
639 XMLAttribute attrib;
640 XMLCSTR text;
641 XMLClear clear;
642

--- 17 unchanged lines hidden (view full) ---

660 * @ingroup XMLParserGeneral
661 * The "xmlto?" functions are equivalents to the atoi, atol, atof functions.
662 * The only difference is: If the variable "xmlString" is NULL, than the return value
663 * is "defautValue". These 6 functions are only here as "convenience" functions for the
664 * user (they are not used inside the XMLparser). If you don't need them, you can
665 * delete them without any trouble.
666 *
667 * @{ */
667XMLDLLENTRY char xmltob(XMLCSTR xmlString,char defautValue=0);
668XMLDLLENTRY int xmltoi(XMLCSTR xmlString,int defautValue=0);
669XMLDLLENTRY long xmltol(XMLCSTR xmlString,long defautValue=0);
670XMLDLLENTRY double xmltof(XMLCSTR xmlString,double defautValue=.0);
671XMLDLLENTRY XMLCSTR xmltoa(XMLCSTR xmlString,XMLCSTR defautValue=_CXML(""));
672XMLDLLENTRY XMLCHAR xmltoc(XMLCSTR xmlString,XMLCHAR defautValue=_CXML('\0'));
668XMLDLLENTRY char xmltob(XMLCSTR xmlString, char defautValue=0);
669XMLDLLENTRY int xmltoi(XMLCSTR xmlString, int defautValue=0);
670XMLDLLENTRY long xmltol(XMLCSTR xmlString, long defautValue=0);
671XMLDLLENTRY double xmltof(XMLCSTR xmlString, double defautValue=.0);
672XMLDLLENTRY XMLCSTR xmltoa(XMLCSTR xmlString, XMLCSTR defautValue=_CXML(""));
673XMLDLLENTRY XMLCHAR xmltoc(XMLCSTR xmlString, XMLCHAR defautValue=_CXML('\0'));
673/** @} */
674
675/** @defgroup ToXMLStringTool Helper class to create XML files using "printf", "fprintf", "cout",... functions.
676 * @ingroup XMLParserGeneral
677 * @{ */
678/// Helper class to create XML files using "printf", "fprintf", "cout",... functions.
679/** The ToXMLStringTool class helps you creating XML files using "printf", "fprintf", "cout",... functions.
680 * The "ToXMLStringTool" class is processing strings so that all the characters
681 * &,",',<,> are replaced by their XML equivalent:
682 * \verbatim &amp;, &quot;, &apos;, &lt;, &gt; \endverbatim
683 * Using the "ToXMLStringTool class" and the "fprintf function" is THE most efficient
684 * way to produce VERY large XML documents VERY fast.
685 * \note If you are creating from scratch an XML file using the provided XMLNode class
686 * you must not use the "ToXMLStringTool" class (because the "XMLNode" class does the
687 * processing job for you during rendering).*/
674/** @} */
675
676/** @defgroup ToXMLStringTool Helper class to create XML files using "printf", "fprintf", "cout",... functions.
677 * @ingroup XMLParserGeneral
678 * @{ */
679/// Helper class to create XML files using "printf", "fprintf", "cout",... functions.
680/** The ToXMLStringTool class helps you creating XML files using "printf", "fprintf", "cout",... functions.
681 * The "ToXMLStringTool" class is processing strings so that all the characters
682 * &,",',<,> are replaced by their XML equivalent:
683 * \verbatim &amp;, &quot;, &apos;, &lt;, &gt; \endverbatim
684 * Using the "ToXMLStringTool class" and the "fprintf function" is THE most efficient
685 * way to produce VERY large XML documents VERY fast.
686 * \note If you are creating from scratch an XML file using the provided XMLNode class
687 * you must not use the "ToXMLStringTool" class (because the "XMLNode" class does the
688 * processing job for you during rendering).*/
688typedef struct XMLDLLENTRY ToXMLStringTool
689{
689typedef struct XMLDLLENTRY ToXMLStringTool {
690public:
690public:
691 ToXMLStringTool(): buf(NULL),buflen(0){}
691 ToXMLStringTool(): buf(NULL), buflen(0){}
692 ~ToXMLStringTool();
693 void freeBuffer();///<call this function when you have finished using this object to release memory used by the internal buffer.
694
695 XMLSTR toXML(XMLCSTR source);///< returns a pointer to an internal buffer that contains a XML-encoded string based on the "source" parameter.
696
697 /** The "toXMLUnSafe" function is deprecated because there is a possibility of
698 * "destination-buffer-overflow". It converts the string
699 * "source" to the string "dest". */

--- 13 unchanged lines hidden (view full) ---

713/** The "XMLParserBase64Tool" class allows you to include any binary data (images, sounds,...)
714 * into an XML document using "Base64 encoding". This class is completely
715 * separated from the rest of the xmlParser library and can be removed without any problem.
716 * To include some binary data into an XML file, you must convert the binary data into
717 * standard text (using "encode"). To retrieve the original binary data from the
718 * b64-encoded text included inside the XML file, use "decode". Alternatively, these
719 * functions can also be used to "encrypt/decrypt" some critical data contained inside
720 * the XML (it's not a strong encryption at all, but sometimes it can be useful). */
692 ~ToXMLStringTool();
693 void freeBuffer();///<call this function when you have finished using this object to release memory used by the internal buffer.
694
695 XMLSTR toXML(XMLCSTR source);///< returns a pointer to an internal buffer that contains a XML-encoded string based on the "source" parameter.
696
697 /** The "toXMLUnSafe" function is deprecated because there is a possibility of
698 * "destination-buffer-overflow". It converts the string
699 * "source" to the string "dest". */

--- 13 unchanged lines hidden (view full) ---

713/** The "XMLParserBase64Tool" class allows you to include any binary data (images, sounds,...)
714 * into an XML document using "Base64 encoding". This class is completely
715 * separated from the rest of the xmlParser library and can be removed without any problem.
716 * To include some binary data into an XML file, you must convert the binary data into
717 * standard text (using "encode"). To retrieve the original binary data from the
718 * b64-encoded text included inside the XML file, use "decode". Alternatively, these
719 * functions can also be used to "encrypt/decrypt" some critical data contained inside
720 * the XML (it's not a strong encryption at all, but sometimes it can be useful). */
721typedef struct XMLDLLENTRY XMLParserBase64Tool
722{
721typedef struct XMLDLLENTRY XMLParserBase64Tool {
723public:
722public:
724 XMLParserBase64Tool(): buf(NULL),buflen(0){}
723 XMLParserBase64Tool(): buf(NULL), buflen(0){}
725 ~XMLParserBase64Tool();
726 void freeBuffer();///< Call this function when you have finished using this object to release memory used by the internal buffer.
727
728 /**
729 * @param formatted If "formatted"=true, some space will be reserved for a carriage-return every 72 chars. */
730 static int encodeLength(int inBufLen, char formatted=0); ///< return the length of the base64 string that encodes a data buffer of size inBufLen bytes.
731
732 /**

--- 32 unchanged lines hidden --- 		724 ~XMLParserBase64Tool();
725 void freeBuffer();///< Call this function when you have finished using this object to release memory used by the internal buffer.
726
727 /**
728 * @param formatted If "formatted"=true, some space will be reserved for a carriage-return every 72 chars. */
729 static int encodeLength(int inBufLen, char formatted=0); ///< return the length of the base64 string that encodes a data buffer of size inBufLen bytes.
730
731 /**

--- 32 unchanged lines hidden ---