/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: XMLString.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(XMLSTRING_HPP) #define XMLSTRING_HPP #include #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN class XMLLCPTranscoder; /** * Class for representing native character strings and handling common string * operations * * This class is Unicode compliant. This class is designed primarily * for internal use, but due to popular demand, it is being made * publicly available. Users of this class must understand that this * is not an officially supported class. All public methods of this * class are static functions. * */ class XMLUTIL_EXPORT XMLString { public: /* Static methods for native character mode string manipulation */ /** @name String concatenation functions */ //@{ /** Concatenates two strings. * * catString appends src to target and * terminates the resulting string with a null character. The initial character * of src overwrites the terminating character of target * . * * No overflow checking is performed when strings are copied or appended. * The behavior of catString is undefined if source and * destination strings overlap. * * @param target Null-terminated destination string * @param src Null-terminated source string */ static void catString ( char* const target , const char* const src ); /** Concatenates two strings. * * catString appends src to target and * terminates the resulting string with a null character. The initial character of * src overwrites the terminating character of target. * No overflow checking is performed when strings are copied or appended. * The behavior of catString is undefined if source and destination * strings overlap. * * @param target Null-terminated destination string * @param src Null-terminated source string */ static void catString ( XMLCh* const target , const XMLCh* const src ); //@} /** @name String comparison functions */ //@{ /** Lexicographically compares lowercase versions of str1 and * str2 and returns a value indicating their relationship. * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareIString ( const char* const str1 , const char* const str2 ); /** Lexicographically compares lowercase versions of str1 and * str2 and returns a value indicating their relationship. * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareIString ( const XMLCh* const str1 , const XMLCh* const str2 ); /** Lexicographically compares lowercase versions of str1 and * str2 and returns a value indicating their relationship. * The routine only lowercases A to Z. * @param str1 Null-terminated ASCII string to compare * @param str2 Null-terminated ASCII string to compare * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareIStringASCII ( const XMLCh* const str1 , const XMLCh* const str2 ); /** Lexicographically compares, at most, the first count characters in * str1 and str2 and returns a value indicating the * relationship between the substrings. * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @param count The number of characters to compare * * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareNString ( const char* const str1 , const char* const str2 , const unsigned int count ); /** Lexicographically compares, at most, the first count characters in * str1 and str2 and returns a value indicating * the relationship between the substrings. * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @param count The number of characters to compare * * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareNString ( const XMLCh* const str1 , const XMLCh* const str2 , const unsigned int count ); /** Lexicographically compares, at most, the first count characters in * str1 and str2 without regard to case and * returns a value indicating the relationship between the substrings. * * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @param count The number of characters to compare * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareNIString ( const char* const str1 , const char* const str2 , const unsigned int count ); /** Lexicographically compares, at most, the first count characters in * str1 and str2 without regard to case and * returns a value indicating the relationship between the substrings. * * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @param count The number of characters to compare * * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareNIString ( const XMLCh* const str1 , const XMLCh* const str2 , const unsigned int count ); /** Lexicographically compares str1 and str2 and * returns a value indicating their relationship. * * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareString ( const char* const str1 , const char* const str2 ); /** Lexicographically compares str1 and str2 and * returns a value indicating their relationship. * * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @return The return value indicates the relation of str1 to * str2 as follows * Less than 0 means str1 is less than str2 * Equal to 0 means str1 is identical to str2 * Greater than 0 means str1 is more than str2 */ static int compareString ( const XMLCh* const str1 , const XMLCh* const str2 ); /** compares str1 and str2 * * @param str1 Null-terminated string to compare * @param str2 Null-terminated string to compare * @return true if two strings are equal, false if not * If one string is null, while the other is zero-length string, * it is considered as equal. */ static bool equals ( const XMLCh* const str1 , const XMLCh* const str2 ); static bool equals ( const char* const str1 , const char* const str2 ); /** Lexicographically compares str1 and str2 * regions and returns true if they are equal, otherwise false. * * A substring of str1 is compared to a substring of * str2. The result is true if these substrings represent * identical character sequences. The substring of str1 * to be compared begins at offset1 and has length charCount. The * substring of str2 to be compared begins at offset2 and * has length charCount. The result is false if and only if at least * one of the following is true: * offset1 is negative. * offset2 is negative. * offset1+charCount is greater than the length of str1. * offset2+charCount is greater than the length of str2. * There is some nonnegative integer k less than charCount such that: * str1.charAt(offset1+k) != str2.charAt(offset2+k) * * @param str1 Null-terminated string to compare * @param offset1 Starting offset of str1 * @param str2 Null-terminated string to compare * @param offset2 Starting offset of str2 * @param charCount The number of characters to compare * @return true if the specified subregion of str1 exactly * matches the specified subregion of str2>; false * otherwise. */ static bool regionMatches ( const XMLCh* const str1 , const int offset1 , const XMLCh* const str2 , const int offset2 , const unsigned int charCount ); /** Lexicographically compares str1 and str2 * regions without regard to case and returns true if they are equal, * otherwise false. * * A substring of str1 is compared to a substring of * str2. The result is true if these substrings represent * identical character sequences. The substring of str1 * to be compared begins at offset1 and has length charCount. The * substring of str2 to be compared begins at offset2 and * has length charCount. The result is false if and only if at least * one of the following is true: * offset1 is negative. * offset2 is negative. * offset1+charCount is greater than the length of str1. * offset2+charCount is greater than the length of str2. * There is some nonnegative integer k less than charCount such that: * str1.charAt(offset1+k) != str2.charAt(offset2+k) * * @param str1 Null-terminated string to compare * @param offset1 Starting offset of str1 * @param str2 Null-terminated string to compare * @param offset2 Starting offset of str2 * @param charCount The number of characters to compare * @return true if the specified subregion of str1 exactly * matches the specified subregion of str2>; false * otherwise. */ static bool regionIMatches ( const XMLCh* const str1 , const int offset1 , const XMLCh* const str2 , const int offset2 , const unsigned int charCount ); //@} /** @name String copy functions */ //@{ /** Copies src, including the terminating null character, to the * location specified by target. * * No overflow checking is performed when strings are copied or appended. * The behavior of strcpy is undefined if the source and destination strings * overlap. * * @param target Destination string * @param src Null-terminated source string */ static void copyString ( char* const target , const char* const src ); /** Copies src, including the terminating null character, to * the location specified by target. * * No overflow checking is performed when strings are copied or appended. * The behavior of copyString is undefined if the source and * destination strings overlap. * * @param target Destination string * @param src Null-terminated source string */ static void copyString ( XMLCh* const target , const XMLCh* const src ); /** Copies src, upto a fixed number of characters, to the * location specified by target. * * No overflow checking is performed when strings are copied or appended. * The behavior of copyNString is undefined if the source and * destination strings overlap. * * @param target Destination string. The size of the buffer should * atleast be 'maxChars + 1'. * @param src Null-terminated source string * @param maxChars The maximum number of characters to copy */ static bool copyNString ( XMLCh* const target , const XMLCh* const src , const unsigned int maxChars ); //@} /** @name Hash functions */ //@{ /** Hashes a string given a modulus * * @param toHash The string to hash * @param hashModulus The divisor to be used for hashing * @param manager The MemoryManager to use to allocate objects * @return Returns the hash value */ static unsigned int hash ( const char* const toHash , const unsigned int hashModulus , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Hashes a string given a modulus * * @param toHash The string to hash * @param hashModulus The divisor to be used for hashing * @param manager The MemoryManager to use to allocate objects * @return Returns the hash value */ static unsigned int hash ( const XMLCh* const toHash , const unsigned int hashModulus , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Hashes a string given a modulus taking a maximum number of characters * as the limit * * @param toHash The string to hash * @param numChars The maximum number of characters to consider for hashing * @param hashModulus The divisor to be used for hashing * @param manager The MemoryManager to use to allocate objects * @return Returns the hash value */ static unsigned int hashN ( const XMLCh* const toHash , const unsigned int numChars , const unsigned int hashModulus , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); //@} /** @name Search functions */ //@{ /** * Provides the index of the first occurance of a character within a string * * @param toSearch The string to search * @param ch The character to search within the string * @return If found, returns the index of the character within the string, * else returns -1. */ static int indexOf(const char* const toSearch, const char ch); /** * Provides the index of the first occurance of a character within a string * * @param toSearch The string to search * @param ch The character to search within the string * @return If found, returns the index of the character within the string, * else returns -1. */ static int indexOf(const XMLCh* const toSearch, const XMLCh ch); /** * Provides the index of the first occurance of a character within a string * starting from a given index * * @param toSearch The string to search * @param chToFind The character to search within the string * @param fromIndex The index to start searching from * @param manager The MemoryManager to use to allocate objects * @return If found, returns the index of the character within the string, * else returns -1. */ static int indexOf ( const char* const toSearch , const char chToFind , const unsigned int fromIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** * Provides the index of the first occurance of a character within a string * starting from a given index * * @param toSearch The string to search * @param chToFind The character to search within the string * @param fromIndex The index to start searching from * @param manager The MemoryManager to use to allocate objects * @return If found, returns the index of the character within the string, * else returns -1. */ static int indexOf ( const XMLCh* const toSearch , const XMLCh chToFind , const unsigned int fromIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** * Provides the index of the last occurance of a character within a string * * @param toSearch The string to search * @param ch The character to search within the string * @return If found, returns the index of the character within the string, * else returns -1. */ static int lastIndexOf(const char* const toSearch, const char ch); /** * Provides the index of the last occurance of a character within a string * * @param toSearch The string to search * @param ch The character to search within the string * @return If found, returns the index of the character within the string, * else returns -1. */ static int lastIndexOf(const XMLCh* const toSearch, const XMLCh ch); /** * Provides the index of the last occurance of a character within a string * * @param ch The character to search within the string * @param toSearch The string to search * @param toSearchLen The length of the string to search * @return If found, returns the index of the character within the string, * else returns -1. */ static int lastIndexOf ( const XMLCh ch , const XMLCh* const toSearch , const unsigned int toSearchLen ); /** * Provides the index of the last occurance of a character within a string * starting backward from a given index * * @param toSearch The string to search * @param chToFind The character to search within the string * @param fromIndex The index to start backward search from * @param manager The MemoryManager to use to allocate objects * @return If found, returns the index of the character within the string, * else returns -1. */ static int lastIndexOf ( const char* const toSearch , const char chToFind , const unsigned int fromIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** * Provides the index of the last occurance of a character within a string * starting backward from a given index * * @param toSearch The string to search * @param ch The character to search within the string * @param fromIndex The index to start backward search from * @param manager The MemoryManager to use to allocate objects * @return If found, returns the index of the character within the string, * else returns -1. */ static int lastIndexOf ( const XMLCh* const toSearch , const XMLCh ch , const unsigned int fromIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); //@} /** @name Fixed size string movement */ //@{ /** Moves X number of chars * @param targetStr The string to copy the chars to * @param srcStr The string to copy the chars from * @param count The number of chars to move */ static void moveChars ( XMLCh* const targetStr , const XMLCh* const srcStr , const unsigned int count ); //@} /** @name Substring function */ //@{ /** Create a substring of a given string. The substring begins at the * specified beginIndex and extends to the character at index * endIndex - 1. * @param targetStr The string to copy the chars to * @param srcStr The string to copy the chars from * @param startIndex beginning index, inclusive. * @param endIndex the ending index, exclusive. * @param manager The MemoryManager to use to allocate objects */ static void subString ( char* const targetStr , const char* const srcStr , const int startIndex , const int endIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Create a substring of a given string. The substring begins at the * specified beginIndex and extends to the character at index * endIndex - 1. * @param targetStr The string to copy the chars to * @param srcStr The string to copy the chars from * @param startIndex beginning index, inclusive. * @param endIndex the ending index, exclusive. * @param manager The MemoryManager to use to allocate objects */ static void subString ( XMLCh* const targetStr , const XMLCh* const srcStr , const int startIndex , const int endIndex , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Create a substring of a given string. The substring begins at the * specified beginIndex and extends to the character at index * endIndex - 1. * @param targetStr The string to copy the chars to * @param srcStr The string to copy the chars from * @param startIndex beginning index, inclusive. * @param endIndex the ending index, exclusive. * @param srcStrLength the length of srcStr * @param manager The MemoryManager to use to allocate objects */ static void subString ( XMLCh* const targetStr , const XMLCh* const srcStr , const int startIndex , const int endIndex , const int srcStrLength , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); //@} /** @name Replication function */ //@{ /** Replicates a string * NOTE: The returned buffer is dynamically allocated and is the * responsibility of the caller to delete it when not longer needed. * You can call XMLString::release to release this returned buffer. * * @param toRep The string to replicate * @return Returns a pointer to the replicated string * @see XMLString::release(char**) */ static char* replicate(const char* const toRep); /** Replicates a string * NOTE: The returned buffer is allocated with the MemoryManager. It is the * responsibility of the caller to delete it when not longer needed. * * @param toRep The string to replicate * @param manager The MemoryManager to use to allocate the string * @return Returns a pointer to the replicated string */ static char* replicate(const char* const toRep, MemoryManager* const manager); /** Replicates a string * NOTE: The returned buffer is dynamically allocated and is the * responsibility of the caller to delete it when not longer needed. * You can call XMLString::release to release this returned buffer. * @param toRep The string to replicate * @return Returns a pointer to the replicated string * @see XMLString::release(XMLCh**) */ static XMLCh* replicate(const XMLCh* const toRep); /** Replicates a string * NOTE: The returned buffer is allocated with the MemoryManager. It is the * responsibility of the caller to delete it when not longer needed. * * @param toRep The string to replicate * @param manager The MemoryManager to use to allocate the string * @return Returns a pointer to the replicated string */ static XMLCh* replicate(const XMLCh* const toRep, MemoryManager* const manager); //@} /** @name String query function */ //@{ /** Tells if the sub-string appears within a string at the beginning * @param toTest The string to test * @param prefix The sub-string that needs to be checked * @return Returns true if the sub-string was found at the beginning of * toTest, else false */ static bool startsWith ( const char* const toTest , const char* const prefix ); /** Tells if the sub-string appears within a string at the beginning * @param toTest The string to test * @param prefix The sub-string that needs to be checked * @return Returns true if the sub-string was found at the beginning of * toTest, else false */ static bool startsWith ( const XMLCh* const toTest , const XMLCh* const prefix ); /** Tells if the sub-string appears within a string at the beginning * without regard to case * * @param toTest The string to test * @param prefix The sub-string that needs to be checked * @return Returns true if the sub-string was found at the beginning of * toTest, else false */ static bool startsWithI ( const char* const toTest , const char* const prefix ); /** Tells if the sub-string appears within a string at the beginning * without regard to case * * @param toTest The string to test * @param prefix The sub-string that needs to be checked * * @return Returns true if the sub-string was found at the beginning * of toTest, else false */ static bool startsWithI ( const XMLCh* const toTest , const XMLCh* const prefix ); /** Tells if the sub-string appears within a string at the end. * @param toTest The string to test * @param suffix The sub-string that needs to be checked * @return Returns true if the sub-string was found at the end of * toTest, else false */ static bool endsWith ( const XMLCh* const toTest , const XMLCh* const suffix ); /** Tells if a string has any occurance of any character of another * string within itself * @param toSearch The string to be searched * @param searchList The string from which characters to be searched for are drawn * @return Returns the pointer to the location where the first occurrence of any * character from searchList is found, * else returns 0 */ static const XMLCh* findAny ( const XMLCh* const toSearch , const XMLCh* const searchList ); /** Tells if a string has any occurance of any character of another * string within itself * @param toSearch The string to be searched * @param searchList The string from which characters to be searched for are drawn * @return Returns the pointer to the location where the first occurrence of any * character from searchList is found, * else returns 0 */ static XMLCh* findAny ( XMLCh* const toSearch , const XMLCh* const searchList ); /** Tells if a string has pattern within itself * @param toSearch The string to be searched * @param pattern The pattern to be located within the string * @return Returns index to the location where the pattern was * found, else returns -1 */ static int patternMatch ( const XMLCh* const toSearch , const XMLCh* const pattern ); /** Get the length of the string * @param src The string whose length is to be determined * @return Returns the length of the string */ static unsigned int stringLen(const char* const src); /** Get the length of the string * @param src The string whose length is to be determined * @return Returns the length of the string */ static unsigned int stringLen(const XMLCh* const src); /** * * Checks whether an name is a valid NOTATION according to XML 1.0 * @param name The string to check its NOTATION validity * @param manager The memory manager * @return Returns true if name is NOTATION valid, otherwise false */ static bool isValidNOTATION(const XMLCh* const name , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); /** * Deprecated: please use XMLChar1_0::isValidNCName * * Checks whether an name is a valid NCName according to XML 1.0 * @param name The string to check its NCName validity * @return Returns true if name is NCName valid, otherwise false */ static bool isValidNCName(const XMLCh* const name); /** * Deprecated: please use XMLChar1_0::isValidName * * Checks whether an name is a valid Name according to XML 1.0 * @param name The string to check its Name validity * @return Returns true if name is Name valid, otherwise false */ static bool isValidName(const XMLCh* const name); /** * Checks whether an name is a valid EncName. * @param name The string to check its EncName validity * @return Returns true if name is EncName valid, otherwise false */ static bool isValidEncName(const XMLCh* const name); /** * Deprecated: please use XMLChar1_0::isValidQName * * Checks whether an name is a valid QName according to XML 1.0 * @param name The string to check its QName validity * @return Returns true if name is QName valid, otherwise false */ static bool isValidQName(const XMLCh* const name); /** * Checks whether a character is within [a-zA-Z]. * @param theChar the character to check * @return Returns true if within the range, otherwise false */ static bool isAlpha(XMLCh const theChar); /** * Checks whether a character is within [0-9]. * @param theChar the character to check * @return Returns true if within the range, otherwise false */ static bool isDigit(XMLCh const theChar); /** * Checks whether a character is within [0-9a-zA-Z]. * @param theChar the character to check * @return Returns true if within the range, otherwise false */ static bool isAlphaNum(XMLCh const theChar); /** * Checks whether a character is within [0-9a-fA-F]. * @param theChar the character to check * @return Returns true if within the range, otherwise false */ static bool isHex(XMLCh const theChar); /** * Deprecated: please use XMLChar1_0::isAllWhiteSpace * * Checks whether aa string contains only whitespace according to XML 1.0 * @param toCheck the string to check * @return Returns true if it is, otherwise false */ static bool isAllWhiteSpace(const XMLCh* const toCheck); /** Find is the string appears in the enum list * @param toFind the string to be found * @param enumList the list * return true if found */ static bool isInList(const XMLCh* const toFind, const XMLCh* const enumList); //@} /** @name Conversion functions */ //@{ /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const unsigned int toFormat , char* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const unsigned int toFormat , XMLCh* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const unsigned long toFormat , char* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const unsigned long toFormat , XMLCh* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const long toFormat , char* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const long toFormat , XMLCh* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const int toFormat , char* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts binary data to a text string based a given radix * * @param toFormat The number to convert * @param toFill The buffer that will hold the output on return. The * size of this buffer should at least be 'maxChars + 1'. * @param maxChars The maximum number of output characters that can be * accepted. If the result will not fit, it is an error. * @param radix The radix of the input data, based on which the conversion * @param manager The MemoryManager to use to allocate objects * will be done */ static void binToText ( const int toFormat , XMLCh* const toFill , const unsigned int maxChars , const unsigned int radix , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** * Converts a string of decimal chars to a binary value * * Note that leading and trailng whitespace is legal and will be ignored * but the remainder must be all decimal digits. * * @param toConvert The string of digits to convert * @param toFill The unsigned int value to fill with the converted * value. * @param manager The MemoryManager to use to allocate objects */ static bool textToBin ( const XMLCh* const toConvert , unsigned int& toFill , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** * Converts a string of decimal chars to a binary value * * Note that leading and trailng whitespace is legal and will be ignored, * * Only one and either of (+,-) after the leading whitespace, before * any other characters are allowed. * * but the remainder must be all decimal digits. * * @param toConvert The string of digits to convert * @param manager The MemoryManager to use to allocate objects */ static int parseInt ( const XMLCh* const toConvert , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Cut leading chars from a string * * @param toCutFrom The string to cut chars from * @param count The count of leading chars to cut */ static void cut ( XMLCh* const toCutFrom , const unsigned int count ); /** Transcodes a string to native code-page * * NOTE: The returned buffer is dynamically allocated and is the * responsibility of the caller to delete it when not longer needed. * You can call XMLString::release to release this returned buffer. * * @param toTranscode The string to be transcoded * @return Returns the transcoded string * @see XMLString::release(XMLCh**) */ static char* transcode ( const XMLCh* const toTranscode ); static char* transcode ( const XMLCh* const toTranscode , MemoryManager* const manager ); /** Transcodes a string to native code-page * * Be aware that when transcoding to an external encoding, that each * Unicode char can create multiple output bytes. So you cannot assume * a one to one correspondence of input chars to output bytes. * * @param toTranscode The string tobe transcoded * @param toFill The buffer that is filled with the transcoded value. * The size of this buffer should atleast be 'maxChars + 1'. * @param maxChars The maximum number of bytes that the output * buffer can hold (not including the null, which is why * toFill should be at least maxChars+1.). * @param manager The MemoryManager to use to allocate objects * @return Returns true if successful, false if there was an error */ static bool transcode ( const XMLCh* const toTranscode , char* const toFill , const unsigned int maxChars , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Transcodes a string to native code-page * * NOTE: The returned buffer is dynamically allocated and is the * responsibility of the caller to delete it when not longer needed. * You can call XMLString::release to release this returned buffer. * * @param toTranscode The string to be transcoded * @return Returns the transcoded string * @see XMLString::release(char**) */ static XMLCh* transcode ( const char* const toTranscode ); static XMLCh* transcode ( const char* const toTranscode , MemoryManager* const manager ); /** Transcodes a string to native code-page * @param toTranscode The string tobe transcoded * @param toFill The buffer that is filled with the transcoded value. * The size of this buffer should atleast be 'maxChars + 1'. * @param maxChars The maximum number of characters that the output * buffer can hold (not including the null, which is why * toFill should be at least maxChars+1.). * @param manager The MemoryManager to use to allocate objects * @return Returns true if successful, false if there was an error */ static bool transcode ( const char* const toTranscode , XMLCh* const toFill , const unsigned int maxChars , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Trims off extra space characters from the start and end of the string, * moving the non-space string content back to the start. * @param toTrim The string to be trimmed. On return this contains the * trimmed string */ static void trim(char* const toTrim); /** Trims off extra space characters from the start and end of the string, * moving the non-space string content back to the start. * @param toTrim The string to be trimmed. On return this contains * the trimmed string */ static void trim(XMLCh* const toTrim); /** Break a string into tokens with space as delimiter, and * stored in a string vector. The caller owns the string vector * that is returned, and is responsible for deleting it. * @param tokenizeSrc String to be tokenized * @param manager The MemoryManager to use to allocate objects * @return a vector of all the tokenized string */ static BaseRefVectorOf* tokenizeString(const XMLCh* const tokenizeSrc , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); //@} /** @name Formatting functions */ //@{ /** Creates a UName from a URI and base name. It is in the form * {url}name, and is commonly used internally to represent fully * qualified names when namespaces are enabled. * * @param pszURI The URI part of the name * @param pszName The base part of the name * @return Returns the complete formatted UName */ static XMLCh* makeUName ( const XMLCh* const pszURI , const XMLCh* const pszName ); /** * Internal function to perform token replacement for strings. * * @param errText The text (NULL terminated) where the replacement * is to be done. The size of this buffer should be * 'maxChars + 1' to account for the final NULL. * @param maxChars The size of the output buffer, i.e. the maximum * number of characters that it will hold. If the result is * larger, it will be truncated. * @param text1 Replacement text-one * @param text2 Replacement text-two * @param text3 Replacement text-three * @param text4 Replacement text-four * @param manager The MemoryManager to use to allocate objects * @return Returns the count of characters that are outputted */ static unsigned int replaceTokens ( XMLCh* const errText , const unsigned int maxChars , const XMLCh* const text1 , const XMLCh* const text2 , const XMLCh* const text3 , const XMLCh* const text4 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); /** Converts a string to uppercase * @param toUpperCase The string which needs to be converted to uppercase. * On return, this buffer also holds the converted uppercase string */ static void upperCase(XMLCh* const toUpperCase); /** Converts a string to uppercase * The routine only uppercases A to Z (other characters not changed). * @param toUpperCase The string which needs to be converted to uppercase. * On return, this buffer also holds the converted uppercase string */ static void upperCaseASCII(XMLCh* const toUpperCase); /** Converts a string to lowercase * @param toLowerCase The string which needs to be converted to lowercase. * On return, this buffer also holds the converted lowercase string */ static void lowerCase(XMLCh* const toLowerCase); /** Converts a string to lowercase * The routine only lowercases a to z (other characters not changed). * @param toLowerCase The string which needs to be converted to lowercase. * On return, this buffer also holds the converted lowercase string */ static void lowerCaseASCII(XMLCh* const toLowerCase); /** Check if string is WhiteSpace:replace * @param toCheck The string which needs to be checked. */ static bool isWSReplaced(const XMLCh* const toCheck); /** Check if string is WhiteSpace:collapse * @param toCheck The string which needs to be checked. */ static bool isWSCollapsed(const XMLCh* const toCheck); /** Replace whitespace * @param toConvert The string which needs to be whitespace replaced. * On return , this buffer also holds the converted string * @param manager The MemoryManager to use to allocate objects */ static void replaceWS(XMLCh* const toConvert , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); /** Collapse whitespace * @param toConvert The string which needs to be whitespace collapsed. * On return , this buffer also holds the converted string * @param manager The MemoryManager to use to allocate objects */ static void collapseWS(XMLCh* const toConvert , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); /** Remove whitespace * @param toConvert The string which needs to be whitespace removed. * On return , this buffer also holds the converted string * @param manager The MemoryManager to use to allocate objects */ static void removeWS(XMLCh* const toConvert , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); /** Remove character * @param srcString The string * @param toRemove The character needs to be removed from the string * @param dstBuffer The buffer containning the result */ static void removeChar(const XMLCh* const srcString , const XMLCh& toRemove , XMLBuffer& dstBuffer); /** * Fixes a platform dependent absolute path filename to standard URI form. * 1. Windows: fix 'x:' to 'file:///x:' and convert any backslash to forward slash * 2. UNIX: fix '/blah/blahblah' to 'file:///blah/blahblah' * @param str The string that has the absolute path filename * @param target The target string pre-allocated to store the fixed uri */ static void fixURI(const XMLCh* const str, XMLCh* const target); //@} /** @name String Memory Management functions */ //@{ /** * Release the parameter char string that was allocated by the implementation (i.e.the parser). * The implementation will call operator delete[] and then turn the string to a null pointer. * * @param buf The string to be deleted and become a null pointer. */ static void release(char** buf); /** * Release the parameter XMLCh string that was allocated by the implementation (i.e.the parser). * The implementation will call operator delete[] and then turn the string to a null pointer. * * @param buf The string to be deleted and become a null pointer. */ static void release(XMLCh** buf); /** * Release the parameter XMLByte string that was allocated by the implementation (i.e.the parser). * The implementation will call operator delete[] and then turn the string to a null pointer. * * @param buf The string to be deleted and become a null pointer. */ static void release(XMLByte** buf); /** * Release the parameter string that was allocated using the version of XMLString::transcode * that accepts a MemoryManager. * The implementation will call MemoryManager::deallocate and then turn the string to a null pointer. * * @param buf The string to be deleted and become a null pointer. * @param manager The MemoryManager to use to allocate objects */ static void release ( void** buf , MemoryManager* const manager ); //@} private : /** @name Constructors and Destructor */ //@{ /** Unimplemented default constructor */ XMLString(); /** Unimplemented destructor */ ~XMLString(); //@} /** @name Initialization */ //@{ /** Init/Term methods called from XMLPlatformUtils class */ static void initString(XMLLCPTranscoder* const defToUse, MemoryManager* const manager); static void termString(); //@} /** * Called by regionMatches/regionIMatches to validate that we * have a valid input */ static bool validateRegion(const XMLCh* const str1, const int offset1, const XMLCh* const str2, const int offset2, const unsigned int charCount); static MemoryManager* fgMemoryManager; friend class XMLPlatformUtils; }; // --------------------------------------------------------------------------- // Inline some methods that are either just passthroughs to other string // methods, or which are key for performance. // --------------------------------------------------------------------------- inline void XMLString::moveChars( XMLCh* const targetStr , const XMLCh* const srcStr , const unsigned int count) { memcpy(targetStr, srcStr, count * sizeof(XMLCh)); } inline unsigned int XMLString::stringLen(const XMLCh* const src) { if (src == 0 || *src == 0) { return 0; } else { const XMLCh* pszTmp = src + 1; while (*pszTmp) ++pszTmp; return (unsigned int)(pszTmp - src); } } inline XMLCh* XMLString::replicate(const XMLCh* const toRep, MemoryManager* const manager) { // If a null string, return a null string! XMLCh* ret = 0; if (toRep) { const unsigned int len = stringLen(toRep); ret = (XMLCh*) manager->allocate((len+1) * sizeof(XMLCh)); //new XMLCh[len + 1]; memcpy(ret, toRep, (len + 1) * sizeof(XMLCh)); } return ret; } inline bool XMLString::startsWith( const XMLCh* const toTest , const XMLCh* const prefix) { return (compareNString(toTest, prefix, stringLen(prefix)) == 0); } inline bool XMLString::startsWithI( const XMLCh* const toTest , const XMLCh* const prefix) { return (compareNIString(toTest, prefix, stringLen(prefix)) == 0); } inline bool XMLString::endsWith(const XMLCh* const toTest, const XMLCh* const suffix) { unsigned int suffixLen = XMLString::stringLen(suffix); return regionMatches(toTest, XMLString::stringLen(toTest) - suffixLen, suffix, 0, suffixLen); } inline bool XMLString::validateRegion(const XMLCh* const str1, const int offset1, const XMLCh* const str2, const int offset2, const unsigned int charCount) { if (offset1 < 0 || offset2 < 0 || (offset1 + charCount) > XMLString::stringLen(str1) || (offset2 + charCount) > XMLString::stringLen(str2) ) return false; return true; } inline bool XMLString::equals( const XMLCh* const str1 , const XMLCh* const str2) { const XMLCh* psz1 = str1; const XMLCh* psz2 = str2; if (psz1 == 0 || psz2 == 0) { if ((psz1 != 0 && *psz1) || (psz2 != 0 && *psz2)) return false; else return true; } while (*psz1 == *psz2) { // If either has ended, then they both ended, so equal if (!*psz1) return true; // Move upwards for the next round psz1++; psz2++; } return false; } inline bool XMLString::equals( const char* const str1 , const char* const str2) { const char* psz1 = str1; const char* psz2 = str2; if (psz1 == 0 || psz2 == 0) { if ((psz1 != 0 && *psz1) || (psz2 != 0 && *psz2)) return false; else return true; } while (*psz1 == *psz2) { // If either has ended, then they both ended, so equal if (!*psz1) return true; // Move upwards for the next round psz1++; psz2++; } return false; } inline int XMLString::lastIndexOf(const XMLCh* const toSearch, const XMLCh ch) { return XMLString::lastIndexOf(ch, toSearch, stringLen(toSearch)); } inline unsigned int XMLString::hash( const XMLCh* const tohash , const unsigned int hashModulus , MemoryManager* const) { assert(hashModulus); if (tohash == 0 || *tohash == 0) return 0; const XMLCh* curCh = tohash; unsigned int hashVal = (unsigned int)(*curCh++); while (*curCh) hashVal = (hashVal * 38) + (hashVal >> 24) + (unsigned int)(*curCh++); // Divide by modulus return hashVal % hashModulus; } XERCES_CPP_NAMESPACE_END #endif