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. |
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 |
164// to have 'mbsrtowcs' for WIDECHAR version |
165#endif 166#endif 167 168// Some common types for char set portable code 169#ifdef _XMLWIDECHAR |
170#define _CXML(c) L ## c 171#define XMLCSTR const wchar_t * 172#define XMLSTR wchar_t * 173#define XMLCHAR wchar_t |
174#else |
175#define _CXML(c) c 176#define XMLCSTR const char * 177#define XMLSTR char * 178#define XMLCHAR char |
179#endif 180#ifndef FALSE |
181#define FALSE 0 |
182#endif /* FALSE */ 183#ifndef TRUE |
184#define TRUE 1 |
185#endif /* TRUE */ 186 187 188/// Enumeration for XML parse errors. |
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 |
216typedef enum XMLElementType { 217 eNodeChild = 0, 218 eNodeAttribute = 1, 219 eNodeText = 2, 220 eNodeClear = 3, 221 eNodeNULL = 4 |
222} XMLElementType; 223 224/// Structure used to obtain error details if the parse fails. |
225typedef struct XMLResults { |
226 enum XMLError error; |
227 int nLine; 228 int nColumn; |
229} XMLResults; 230 231/// Structure for XML clear (unformatted) node (usually comments) 232typedef struct XMLClear { |
233 XMLCSTR lpszValue; 234 XMLCSTR lpszOpenTag; 235 XMLCSTR lpszCloseTag; |
236} XMLClear; 237 238/// Structure for XML attribute. 239typedef struct XMLAttribute { |
240 XMLCSTR lpszName; 241 XMLCSTR lpszValue; |
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> */ |
261typedef struct XMLDLLENTRY XMLNode { 262private: |
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 |
271public: |
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. |
279 static XMLNode parseString(XMLCSTR lpXMLString, XMLCSTR tag = NULL, 280 XMLResults *pResults = NULL); |
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. |
293 static XMLNode parseFile(XMLCSTR filename, XMLCSTR tag = NULL, 294 XMLResults *pResults = NULL); |
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. |
307 static XMLNode openFileHelper(XMLCSTR filename, XMLCSTR tag = NULL); |
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. |
328 XMLSTR createXMLString(int nFormat = 1, int *pnSize = NULL) const; |
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, |
336 const char *encoding = NULL, 337 char nFormat = 1) const; |
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; |
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='/'); |
361 ///< return the first child node with specific path |
362 XMLNode getChildNodeByPathNonConst(XMLSTR path, char createNodeIfMissing=0, XMLCHAR sep='/'); |
363 ///< return the first child node with specific path. |
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 |
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 |
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 |
430 XMLClear *updateClear(XMLClear *newP, XMLClear *oldP); ///< if the clearTag 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 |
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 |
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 |
494 XMLClear *updateClear_WOSD(XMLClear *newP, XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added |
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. |
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 |
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 |
595private: 596 // these are functions and structures used internally by the XMLNode class (don't bother about them): |
597 |
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; |
614 |
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); |
631} XMLNode; 632 633/// This structure is given by the function XMLNode::enumContents. |
634typedef struct XMLNodeContents { |
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 * @{ */ |
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')); |
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 &, ", ', <, > \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).*/ |
689typedef struct XMLDLLENTRY ToXMLStringTool { |
690public: |
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). */ |
721typedef struct XMLDLLENTRY XMLParserBase64Tool { |
722public: |
723 XMLParserBase64Tool(): buf(NULL), buflen(0){} |
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 --- |