secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/util/XMLString.hpp
/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
/*
* 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 <xercesc/util/BaseRefVectorOf.hpp>
#include <xercesc/framework/XMLBuffer.hpp>
#include <xercesc/framework/MemoryManager.hpp>
#include <string.h>
#include <assert.h>
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 <i>static functions</i>.
*
*/
class XMLUTIL_EXPORT XMLString
{
public:
/* Static methods for native character mode string manipulation */
/** @name String concatenation functions */
//@{
/** Concatenates two strings.
*
* <code>catString</code> appends <code>src</code> to <code>target</code> and
* terminates the resulting string with a null character. The initial character
* of <code>src</code> overwrites the terminating character of <code>target
* </code>.
*
* No overflow checking is performed when strings are copied or appended.
* The behavior of <code>catString</code> 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.
*
* <code>catString</code> appends <code>src</code> to <code>target</code> and
* terminates the resulting string with a null character. The initial character of
* <code>src</code> overwrites the terminating character of <code>target</code>.
* No overflow checking is performed when strings are copied or appended.
* The behavior of <code>catString</code> 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 <code>str1</code> and
* <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareIString
(
const char* const str1
, const char* const str2
);
/** Lexicographically compares lowercase versions of <code>str1</code> and
* <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareIString
(
const XMLCh* const str1
, const XMLCh* const str2
);
/** Lexicographically compares lowercase versions of <code>str1</code> and
* <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareIStringASCII
(
const XMLCh* const str1
, const XMLCh* const str2
);
/** Lexicographically compares, at most, the first count characters in
* <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareNString
(
const char* const str1
, const char* const str2
, const unsigned int count
);
/** Lexicographically compares, at most, the first count characters in
* <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareNString
(
const XMLCh* const str1
, const XMLCh* const str2
, const unsigned int count
);
/** Lexicographically compares, at most, the first count characters in
* <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareNIString
(
const char* const str1
, const char* const str2
, const unsigned int count
);
/** Lexicographically compares, at most, the first count characters in
* <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareNIString
(
const XMLCh* const str1
, const XMLCh* const str2
, const unsigned int count
);
/** Lexicographically compares <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareString
(
const char* const str1
, const char* const str2
);
/** Lexicographically compares <code>str1</code> and <code>str2</code> 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 <code>str1</code> to
* <code>str2</code> as follows
* Less than 0 means <code>str1</code> is less than <code>str2</code>
* Equal to 0 means <code>str1</code> is identical to <code>str2</code>
* Greater than 0 means <code>str1</code> is more than <code>str2</code>
*/
static int compareString
(
const XMLCh* const str1
, const XMLCh* const str2
);
/** compares <code>str1</code> and <code>str2</code>
*
* @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 <code>str1</code> and <code>str2</code>
* regions and returns true if they are equal, otherwise false.
*
* A substring of <code>str1</code> is compared to a substring of
* <code>str2</code>. The result is true if these substrings represent
* identical character sequences. The substring of <code>str1</code>
* to be compared begins at offset1 and has length charCount. The
* substring of <code>str2</code> 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 <code>str1</code> exactly
* matches the specified subregion of <code>str2></code>; 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 <code>str1</code> and <code>str2</code>
* regions without regard to case and returns true if they are equal,
* otherwise false.
*
* A substring of <code>str1</code> is compared to a substring of
* <code>str2</code>. The result is true if these substrings represent
* identical character sequences. The substring of <code>str1</code>
* to be compared begins at offset1 and has length charCount. The
* substring of <code>str2</code> 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 <code>str1</code> exactly
* matches the specified subregion of <code>str2></code>; 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 <code>src</code>, including the terminating null character, to the
* location specified by <code>target</code>.
*
* 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 <code>src</code>, including the terminating null character, to
* the location specified by <code>target</code>.
*
* No overflow checking is performed when strings are copied or appended.
* The behavior of <code>copyString</code> 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 <code>src</code>, upto a fixed number of characters, to the
* location specified by <code>target</code>.
*
* No overflow checking is performed when strings are copied or appended.
* The behavior of <code>copyNString</code> 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
* <code>toTest</code>, 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
* <code>toTest</code>, 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
* <code>toTest</code>, 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 <code>toTest</code>, 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
* <code>toTest</code>, 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<XMLCh>* 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