Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.7

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

DOMStringHelper.hpp

Go to the documentation of this file.
00001 /*
00002  * The Apache Software License, Version 1.1
00003  *
00004  *
00005  * Copyright (c) 1999-2004 The Apache Software Foundation.  All rights 
00006  * reserved.
00007  *
00008  * Redistribution and use in source and binary forms, with or without
00009  * modification, are permitted provided that the following conditions
00010  * are met:
00011  *
00012  * 1. Redistributions of source code must retain the above copyright
00013  *    notice, this list of conditions and the following disclaimer. 
00014  *
00015  * 2. Redistributions in binary form must reproduce the above copyright
00016  *    notice, this list of conditions and the following disclaimer in
00017  *    the documentation and/or other materials provided with the
00018  *    distribution.
00019  *
00020  * 3. The end-user documentation included with the redistribution,
00021  *    if any, must include the following acknowledgment:  
00022  *       "This product includes software developed by the
00023  *        Apache Software Foundation (http://www.apache.org/)."
00024  *    Alternately, this acknowledgment may appear in the software itself,
00025  *    if and wherever such third-party acknowledgments normally appear.
00026  *
00027  * 4. The names "Xalan" and "Apache Software Foundation" must
00028  *    not be used to endorse or promote products derived from this
00029  *    software without prior written permission. For written 
00030  *    permission, please contact apache@apache.org.
00031  *
00032  * 5. Products derived from this software may not be called "Apache",
00033  *    nor may "Apache" appear in their name, without prior written
00034  *    permission of the Apache Software Foundation.
00035  *
00036  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
00037  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00038  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00039  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
00040  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00041  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00042  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
00043  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00044  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00045  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
00046  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00047  * SUCH DAMAGE.
00048  * ====================================================================
00049  *
00050  * This software consists of voluntary contributions made by many
00051  * individuals on behalf of the Apache Software Foundation and was
00052  * originally based on software copyright (c) 1999, International
00053  * Business Machines, Inc., http://www.ibm.com.  For more
00054  * information on the Apache Software Foundation, please see
00055  * <http://www.apache.org/>.
00056  */
00057 #if !defined(DOMSTRINGHELPER_HEADER_GUARD_1357924680)
00058 #define DOMSTRINGHELPER_HEADER_GUARD_1357924680
00059 
00060 
00061 
00062 // Base include file.  Must be first.
00063 #include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp>
00064 
00065 
00066 
00067 #include <algorithm>
00068 #include <cassert>
00069 #include <functional>
00070 #if defined(XALAN_CLASSIC_IOSTREAMS)
00071 class ostream;
00072 #else
00073 #include <iosfwd>
00074 #endif
00075 #include <vector>
00076 
00077 
00078 
00079 #include <xalanc/XalanDOM/XalanDOMString.hpp>
00080 
00081 
00082 
00083 #include <xalanc/PlatformSupport/FormatterListener.hpp>
00084 #include <xalanc/PlatformSupport/XalanUnicode.hpp>
00085 #include <xalanc/PlatformSupport/XalanXMLChar.hpp>
00086 
00087 
00088 
00089 XALAN_CPP_NAMESPACE_BEGIN
00090 
00091 
00092 
00093 class XalanOutputStream;
00094 
00095 
00096 
00097 // This macro has been defined to deal with certain C++ compilers which
00098 // do not create Unicode strings when the "L" string constant prefix is
00099 // used.  It is meant _only_ for use with static strings.
00100 #if defined(XALAN_LSTRSUPPORT) && !defined(XALAN_XALANDOMCHAR_USHORT_MISMATCH)
00101 
00102 #define XALAN_STATIC_UCODE_STRING(str) L##str
00103 
00114 inline const XalanDOMString
00115 StaticStringToDOMString(const XalanDOMChar*     theString)
00116 {
00117     return XalanDOMString(theString);
00118 }
00119 
00120 #else
00121 
00122 #define XALAN_STATIC_UCODE_STRING(str) XALAN_CPP_NAMESPACE_QUALIFIER TranscodeFromLocalCodePage(str)
00123 
00132 inline const XalanDOMString&
00133 StaticStringToDOMString(const XalanDOMString&   theString)
00134 {
00135     return theString;
00136 }
00137 
00138 #endif
00139 
00140 
00141 
00142 #if defined(XALAN_NO_ALGORITHMS_WITH_BUILTINS)
00143 
00144 template<class InputIteratorType, class OutputIteratorType>
00145 inline OutputIteratorType
00146 XalanCopy(
00147             InputIteratorType   begin,
00148             InputIteratorType   end,
00149             OutputIteratorType  iterator)
00150 {
00151     for(; begin != end; ++iterator, ++begin)
00152     {
00153         *iterator = *begin;
00154     }
00155 
00156     return iterator;
00157 }
00158 
00159 
00160 
00161 template<class InputIteratorType, class OutputIteratorType, class UnaryFunction>
00162 inline OutputIteratorType
00163 XalanTransform(
00164             InputIteratorType   begin,
00165             InputIteratorType   end,
00166             OutputIteratorType  iterator,
00167             UnaryFunction       function)
00168 {
00169     for(; begin != end; ++iterator, ++begin)
00170     {
00171         *iterator = function(*begin);
00172     }
00173 
00174     return iterator;
00175 }
00176 
00177 #else
00178 
00179 template<class InputIteratorType, class OutputIteratorType>
00180 inline OutputIteratorType
00181 XalanCopy(
00182             InputIteratorType   begin,
00183             InputIteratorType   end,
00184             OutputIteratorType  iterator)
00185 {
00186     return XALAN_STD_QUALIFIER copy(begin, end, iterator);
00187 }
00188 
00189 
00190 
00191 template<class InputIteratorType, class OutputIteratorType, class UnaryFunction>
00192 inline OutputIteratorType
00193 XalanTransform(
00194             InputIteratorType   begin,
00195             InputIteratorType   end,
00196             OutputIteratorType  iterator,
00197             UnaryFunction       function)
00198 {
00199     return XALAN_STD_QUALIFIER transform(begin, end, iterator);
00200 }
00201 
00202 #endif
00203 
00204 
00205 
00213 inline const XalanDOMChar*
00214 c_wstr(const XalanDOMString&    theString)
00215 {
00216     return theString.c_str();
00217 }
00218 
00219 
00220 
00228 inline const char*
00229 c_str(const CharVectorType&     theString)
00230 {
00231     if (theString.empty() == true)
00232     {
00233         return 0;
00234     }
00235     else
00236     {
00237         const char* const   ptr = &theString[0];
00238 
00239         assert(ptr[theString.size() - 1] == '\0');
00240 
00241         return ptr;
00242     }
00243 }
00244 
00245 
00246 
00262 inline const XalanDOMChar*
00263 c_wstr(const XalanDOMChar*  theString)
00264 {
00265     return theString;
00266 }
00267 
00268 
00269 
00277 inline const XalanDOMChar*
00278 toCharArray(const XalanDOMString&   theString)
00279 {
00280     return theString.c_str();
00281 }
00282 
00283 
00284 
00291 inline const XalanDOMChar*
00292 toCharArray(const XalanDOMChar*     theString)
00293 {
00294     return theString;
00295 }
00296 
00297 
00298 
00306 inline const char*
00307 toCharArray(const CharVectorType&   theString)
00308 {
00309     return theString.empty() == true ? 0 : &theString[0];
00310 }
00311 
00312 
00313 
00321 inline void
00322 reserve(
00323             XalanDOMString&             theString,
00324             XalanDOMString::size_type   theCount)
00325 {
00326     theString.reserve(theCount);
00327 }
00328 
00329 
00330 
00337 inline XalanDOMString::size_type
00338 length(const XalanDOMString&    theString)
00339 {
00340     return theString.length();
00341 }
00342 
00343 
00344 
00352 inline XalanDOMString::size_type
00353 length(const XalanDOMChar*  theString)
00354 {
00355     assert(theString != 0);
00356 
00357     const XalanDOMChar*     theBufferPointer = theString;
00358 
00359     while(*theBufferPointer != 0)
00360     {
00361         theBufferPointer++;
00362     }
00363 
00364     return XalanDOMString::size_type(theBufferPointer - theString);
00365 }
00366 
00367 
00368 
00375 inline XalanDOMString::size_type
00376 length(const char*  theString)
00377 {
00378     assert(theString != 0);
00379 
00380     return XalanDOMString::length(theString);
00381 }
00382 
00383 
00384 
00391 inline bool 
00392 isEmpty(const XalanDOMString&   str)
00393 {
00394     return str.empty(); 
00395 }
00396 
00397 
00398 
00408 inline XalanDOMString::size_type
00409 indexOf(
00410             const XalanDOMChar*     theString,
00411             XalanDOMChar            theChar)
00412 {
00413     assert(theString != 0);
00414 
00415     const XalanDOMChar*     thePointer = theString;
00416 
00417     while(*thePointer != theChar && *thePointer != 0)
00418     {
00419         ++thePointer;
00420     }
00421 
00422     return XalanDOMString::size_type(thePointer - theString);
00423 }
00424 
00425 
00426 
00437 inline XalanDOMString::size_type
00438 indexOf(
00439             const XalanDOMChar*         theString,
00440             XalanDOMString::size_type   theStringLength,
00441             XalanDOMChar                theChar)
00442 {
00443     assert(theString != 0);
00444 
00445     const XalanDOMChar*         thePointer = theString;
00446     const XalanDOMChar* const   theEndPointer = theString + theStringLength;
00447 
00448     while(*thePointer != theChar && thePointer != theEndPointer)
00449     {
00450         ++thePointer;
00451     }
00452 
00453     return XalanDOMString::size_type(thePointer - theString);
00454 }
00455 
00456 
00457 
00467 inline XalanDOMString::size_type
00468 indexOf(
00469             const XalanDOMString&   theString,
00470             XalanDOMChar            theChar)
00471 {
00472     return length(theString) == 0 ? 0 : indexOf(c_wstr(theString), theChar);
00473 }
00474 
00475 
00476 
00488 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
00489 indexOf(
00490             const XalanDOMChar*         theString,
00491             XalanDOMString::size_type   theStringLength,
00492             const XalanDOMChar*         theSubstring,
00493             XalanDOMString::size_type   theSubstringLength);
00494 
00495 
00496 
00506 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
00507 indexOf(
00508             const XalanDOMChar*     theString,
00509             const XalanDOMChar*     theSubstring);
00510 
00511 
00512 
00522 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
00523 indexOf(
00524             const XalanDOMString&   theString,
00525             const XalanDOMString&   theSubstring);
00526 
00527 
00528 
00538 
00539 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
00540 lastIndexOf(
00541             const XalanDOMChar*     theString,
00542             XalanDOMChar            theChar);
00543 
00544 
00545 
00555 inline XalanDOMString::size_type
00556 lastIndexOf(
00557             const XalanDOMString&   theString,
00558             XalanDOMChar            theChar)
00559 {
00560     return lastIndexOf(c_wstr(theString), theChar);
00561 }
00562 
00563 
00564 
00574 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
00575 startsWith(
00576             const XalanDOMChar*         theString,
00577             XalanDOMString::size_type   theStringLength,
00578             const XalanDOMChar*         theSubstring,
00579             XalanDOMString::size_type   theSubstringLength);
00580 
00581 
00582 
00590 inline bool
00591 startsWith(
00592             const XalanDOMChar*     theString,
00593             const XalanDOMChar*     theSubstring)
00594 {
00595     assert(theString != 0 && theSubstring != 0);
00596 
00597     return startsWith(theString, length(theString), theSubstring, length(theSubstring));
00598 }
00599 
00600 
00601 
00609 inline bool
00610 startsWith(
00611             const XalanDOMChar*     theString,
00612             const XalanDOMString&   theSubstring)
00613 {
00614     assert(theString != 0);
00615 
00616     return startsWith(theString, length(theString), c_wstr(theSubstring), length(theSubstring));
00617 }
00618 
00619 
00620 
00628 inline bool
00629 startsWith(
00630             const XalanDOMString&   theString,
00631             const XalanDOMChar*     theSubstring)
00632 {
00633     assert(theSubstring != 0);
00634 
00635     return startsWith(c_wstr(theString), length(theString), theSubstring, length(theSubstring));
00636 }
00637 
00638 
00639 
00648 inline bool
00649 startsWith(
00650             const XalanDOMString&       theString,
00651             const XalanDOMChar*         theSubstring,
00652             XalanDOMString::size_type   theSubstringLength)
00653 {
00654     assert(theSubstring != 0);
00655 
00656     return startsWith(c_wstr(theString), length(theString), theSubstring, theSubstringLength);
00657 }
00658 
00659 
00660 
00668 inline bool
00669 startsWith(
00670             const XalanDOMString&   theString,
00671             const XalanDOMString&   theSubstring)
00672 {
00673     return startsWith(c_wstr(theString), length(theString), c_wstr(theSubstring), length(theSubstring));
00674 }
00675 
00676 
00677 
00685 inline bool
00686 startsWith(
00687             const XalanDOMString&   theString,
00688             const char*             theSubstring)
00689 {
00690     return startsWith(
00691             theString,
00692             XalanDOMString(theSubstring));
00693 }
00694 
00695 
00696 
00704 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
00705 endsWith(
00706             const XalanDOMChar*         theString,
00707             XalanDOMString::size_type   theStringLength,
00708             const XalanDOMChar*         theSubstring,
00709             XalanDOMString::size_type   theSubstringLength);
00710 
00711 
00712 
00720 inline bool
00721 endsWith(
00722             const XalanDOMChar*     theString,
00723             const XalanDOMChar*     theSubstring)
00724 {
00725     assert(theString != 0 && theSubstring != 0);
00726 
00727     return endsWith(theString, length(theString), theSubstring, length(theSubstring));
00728 }
00729 
00730 
00731 
00739 inline bool
00740 endsWith(
00741             const XalanDOMString&   theString,
00742             const XalanDOMString&   theSubstring)
00743 {
00744     return endsWith(c_wstr(theString), length(theString), c_wstr(theSubstring), length(theSubstring));
00745 }
00746 
00747 
00748 
00756 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00757 PointerToDOMString(
00758             const void*         theValue,
00759             XalanDOMString&     theResult);
00760 
00761 
00762 
00769 inline const XalanDOMString
00770 PointerToDOMString(const void*  theValue)
00771 {
00772     XalanDOMString  theResult;
00773 
00774     PointerToDOMString(theValue, theResult);
00775 
00776     return theResult;
00777 }
00778 
00779 
00780 
00788 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00789 DoubleToDOMString(
00790             double              theValue,
00791             XalanDOMString&     theResult);
00792 
00793 
00794 
00801 inline const XalanDOMString
00802 DoubleToDOMString(double    theValue)
00803 {
00804     XalanDOMString  theResult;
00805 
00806     DoubleToDOMString(theValue, theResult);
00807 
00808     return theResult;
00809 }
00810 
00811 
00812 
00813 class XALAN_PLATFORMSUPPORT_EXPORT DOMStringHelper
00814 {
00815 public:
00816 
00817     typedef void (FormatterListener::*MemberFunctionPtr)(const XMLCh* const, const unsigned int);
00818 
00819     static void
00820     DoubleToCharacters(
00821             double              theDouble,
00822             FormatterListener&  formatterListener,
00823             MemberFunctionPtr   function);
00824 
00825     static void
00826     LongToCharacters(
00827             long                theLong,
00828             FormatterListener&  formatterListener,
00829             MemberFunctionPtr   function);
00830 };
00831 
00832 
00833 
00842 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00843 LongToHexDOMString(
00844             long                theValue,
00845             XalanDOMString&     theResult);
00846 
00847 
00848 
00856 inline const XalanDOMString
00857 LongToHexDOMString(long     theValue)
00858 {
00859     XalanDOMString  theResult;
00860 
00861     LongToHexDOMString(theValue, theResult);
00862 
00863     return theResult;
00864 }
00865 
00866 
00867 
00876 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00877 UnsignedLongToHexDOMString(
00878             unsigned long       theValue,
00879             XalanDOMString&     theResult);
00880 
00881 
00882 
00890 inline const XalanDOMString
00891 UnsignedLongToHexDOMString(unsigned long    theValue)
00892 {
00893     XalanDOMString  theResult;
00894 
00895     UnsignedLongToHexDOMString(theValue, theResult);
00896 
00897     return theResult;
00898 }
00899 
00900 
00901 
00909 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00910 LongToDOMString(
00911             long                theValue,
00912             XalanDOMString&     theResult);
00913 
00914 
00915 
00922 inline const XalanDOMString
00923 LongToDOMString(long    theValue)
00924 {
00925     XalanDOMString  theResult;
00926 
00927     LongToDOMString(theValue, theResult);
00928 
00929     return theResult;
00930 }
00931 
00932 
00933 
00942 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
00943 UnsignedLongToDOMString(
00944             unsigned long       theValue,
00945             XalanDOMString&     theResult);
00946 
00947 
00948 
00955 inline const XalanDOMString
00956 UnsignedLongToDOMString(unsigned long   theValue)
00957 {
00958     XalanDOMString  theResult;
00959 
00960     UnsignedLongToDOMString(theValue, theResult);
00961 
00962     return theResult;
00963 }
00964 
00965 
00966 
00973 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
00974 WideStringToInt(const XalanDOMChar*     theString);
00975 
00976 
00977 
00984 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(long)
00985 WideStringToLong(const XalanDOMChar*    theString);
00986 
00987 
00988 
00995 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(unsigned long)
00996 WideStringToUnsignedLong(const XalanDOMChar*    theString);
00997 
00998 
00999 
01006 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(double)
01007 WideStringToDouble(const XalanDOMChar*  theString);
01008 
01009 
01010 
01017 inline int
01018 DOMStringToInt(const XalanDOMString&    theString)
01019 {
01020     return WideStringToInt(c_wstr(theString));
01021 }
01022 
01023 
01024 
01031 inline long
01032 DOMStringToLong(const XalanDOMString&   theString)
01033 {
01034     return WideStringToLong(c_wstr(theString));
01035 }
01036 
01037 
01038 
01045 inline unsigned long
01046 DOMStringToUnsignedLong(const XalanDOMString&   theString)
01047 {
01048     return WideStringToUnsignedLong(c_wstr(theString));
01049 }
01050 
01051 
01052 
01059 inline double
01060 DOMStringToDouble(const XalanDOMString&     theString)
01061 {
01062     return WideStringToDouble(c_wstr(theString));
01063 }
01064 
01065 
01066 
01074 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
01075 OutputString(
01076             XalanOutputStream&      theStream,
01077             const CharVectorType&   theString);
01078 
01079 
01080 
01088 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
01089 OutputString(
01090 #if defined(XALAN_NO_STD_NAMESPACE)
01091             ostream&                theStream,
01092 #else
01093             std::ostream&           theStream,
01094 #endif
01095             const CharVectorType&   theString);
01096 
01097 
01098 
01106 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
01107 OutputString(
01108             XalanOutputStream&      theStream,
01109             const XalanDOMChar*     theString);
01110 
01111 
01112 
01120 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
01121 OutputString(
01122 #if defined(XALAN_NO_STD_NAMESPACE)
01123             ostream&                theStream,
01124 #else
01125             std::ostream&           theStream,
01126 #endif
01127             const XalanDOMChar*     theString);
01128 
01129 
01130 
01138 inline void
01139 OutputString(
01140             XalanOutputStream&      theStream,
01141             const XalanDOMString&   theString)
01142 {
01143     if (isEmpty(theString) == false)
01144     {
01145         OutputString(theStream, c_wstr(theString));
01146     }
01147 }
01148 
01149 
01150 
01158 inline void
01159 OutputString(
01160 #if defined(XALAN_NO_STD_NAMESPACE)
01161             ostream&                theStream,
01162 #else
01163             std::ostream&           theStream,
01164 #endif
01165             const XalanDOMString&   theString)
01166 {
01167     OutputString(theStream, c_wstr(theString));
01168 }
01169 
01170 
01171 
01179 inline XalanOutputStream&
01180 operator<<(
01181             XalanOutputStream&      theStream,
01182             const CharVectorType&   theString)
01183 {
01184     OutputString(theStream, theString);
01185 
01186     return theStream;
01187 }
01188 
01189 
01190 
01198 #if defined(XALAN_NO_STD_NAMESPACE)
01199 inline ostream&
01200 operator<<(
01201             ostream&                theStream,
01202 #else
01203 inline std::ostream&
01204 operator<<(
01205             std::ostream&           theStream,
01206 #endif
01207             const CharVectorType&   theString)
01208 {
01209     OutputString(theStream, theString);
01210 
01211     return theStream;
01212 }
01213 
01214 
01215 
01223 inline XalanOutputStream&
01224 operator<<(
01225             XalanOutputStream&      theStream,
01226             const XalanDOMChar*     theString)
01227 {
01228     OutputString(theStream,
01229                  theString);
01230 
01231     return theStream;
01232 }
01233 
01234 
01235 
01243 #if defined(XALAN_NO_STD_NAMESPACE)
01244 inline ostream&
01245 operator<<(
01246             ostream&                theStream,
01247 #else
01248 inline std::ostream&
01249 operator<<(
01250             std::ostream&           theStream,
01251 #endif
01252             const XalanDOMChar*     theString)
01253 {
01254     OutputString(theStream,
01255                  theString);
01256 
01257     return theStream;
01258 }
01259 
01260 
01261 
01269 inline XalanOutputStream&
01270 operator<<(
01271             XalanOutputStream&      theStream,
01272             const XalanDOMString&   theString)
01273 {
01274     OutputString(theStream,
01275                  theString);
01276 
01277     return theStream;
01278 }
01279 
01280 
01281 
01289 #if defined(XALAN_NO_STD_NAMESPACE)
01290 inline ostream&
01291 operator<<(
01292             ostream&                theStream,
01293 #else
01294 inline std::ostream&
01295 operator<<(
01296             std::ostream&           theStream,
01297 #endif
01298             const XalanDOMString&   theString)
01299 {
01300     OutputString(theStream,
01301                  theString);
01302 
01303     return theStream;
01304 }
01305 
01306 
01307 
01315 inline XalanDOMChar
01316 charAt(
01317             const XalanDOMString&       theString,
01318             XalanDOMString::size_type   theIndex)
01319 {
01320     return theString[theIndex];
01321 }
01322 
01323 
01324 
01331 inline bool
01332 isXMLWhitespace(XalanDOMChar    theChar)
01333 {
01334     return XalanXMLChar::isWhitespace(theChar);
01335 }
01336 
01337 
01338 
01345 inline bool
01346 isXMLDigit(XalanDOMChar     theChar)
01347 {   
01348     return XalanXMLChar::isDigit(theChar);
01349 }
01350 
01351 
01352 
01359 inline bool
01360 isXMLLetterOrDigit(XalanDOMChar     theChar)
01361 {
01362     return  XalanXMLChar::isDigit(theChar) || 
01363             XalanXMLChar::isLetter(theChar);
01364 }
01365 
01366 
01367 
01379 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01380 substring(
01381             const XalanDOMChar*         theString,
01382             XalanDOMString::size_type   theStartIndex,
01383             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
01384 
01385 
01386 
01399 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
01400 substring(
01401             const XalanDOMChar*         theString,
01402             XalanDOMString&             theSubstring,
01403             XalanDOMString::size_type   theStartIndex,
01404             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
01405 
01406 
01407 
01419 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
01420 substring(
01421             const XalanDOMString&       theString,
01422             XalanDOMString&             theSubstring,
01423             XalanDOMString::size_type   theStartIndex,
01424             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
01425 
01426 
01427 
01439 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01440 substring(
01441             const XalanDOMString&       theString,
01442             XalanDOMString::size_type   theStartIndex,
01443             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
01444 
01445 
01446 
01455 inline XalanDOMChar
01456 toLowerASCII(XalanDOMChar   theChar)
01457 {
01458     if (theChar >= XalanUnicode::charLetter_A && theChar <= XalanUnicode::charLetter_Z)
01459     {
01460         return XalanDOMChar(theChar - (XalanUnicode::charLetter_A - XalanUnicode::charLetter_a));
01461     }
01462     else
01463     {
01464         return theChar;
01465     }
01466 }
01467 
01468 
01469 
01478 inline XalanDOMChar
01479 toUpperASCII(XalanDOMChar   theChar)
01480 {
01481     if (theChar >= XalanUnicode::charLetter_a && theChar <= XalanUnicode::charLetter_z)
01482     {
01483         return XalanDOMChar(theChar + (XalanUnicode::charLetter_A - XalanUnicode::charLetter_a));
01484     }
01485     else
01486     {
01487         return theChar;
01488     }
01489 }
01490 
01491 
01492 
01501 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01502 toLowerCaseASCII(const XalanDOMChar*    theString);
01503 
01504 
01505 
01514 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01515 toLowerCaseASCII(const XalanDOMString&  theString);
01516 
01517 
01518 
01527 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01528 toUpperCaseASCII(const XalanDOMChar*    theString);
01529 
01530 
01531 
01540 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
01541 toUpperCaseASCII(const XalanDOMString&  theString);
01542 
01543 
01544 
01557 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
01558 compare(
01559             const CharVectorType&   theLHS,
01560             const CharVectorType&   theRHS);
01561 
01562 
01563 
01577 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
01578 compare(
01579             const XalanDOMChar*         theLHS,
01580             XalanDOMString::size_type   theLHSLength,
01581             const XalanDOMChar*         theRHS,
01582             XalanDOMString::size_type   theRHSLength);
01583 
01584 
01585 
01597 inline int
01598 compare(
01599             const XalanDOMChar*     theLHS,
01600             const XalanDOMChar*     theRHS)
01601 {
01602     return compare(theLHS, length(theLHS), theRHS, length(theRHS));
01603 }
01604 
01605 
01606 
01620 inline int
01621 compare(
01622             const XalanDOMString&   theLHS,
01623             const XalanDOMString&   theRHS)
01624 {
01625     return compare(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
01626 }
01627 
01628 
01629 
01641 inline int
01642 compare(
01643             const XalanDOMChar*     theLHS,
01644             const XalanDOMString&   theRHS)
01645 {
01646     return compare(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
01647 }
01648 
01649 
01650 
01662 inline int
01663 compare(
01664             const XalanDOMString&   theLHS,
01665             const XalanDOMChar*     theRHS)
01666 {
01667     return compare(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
01668 }
01669 
01670 
01671 
01687 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
01688 compareIgnoreCaseASCII(
01689             const XalanDOMChar*         theLHS,
01690             XalanDOMString::size_type   theLHSLength,
01691             const XalanDOMChar*         theRHS,
01692             XalanDOMString::size_type   theRHSLength);
01693 
01694 
01695 
01709 inline int
01710 compareIgnoreCaseASCII(
01711             const XalanDOMChar*     theLHS,
01712             const XalanDOMChar*     theRHS)
01713 {
01714     return compareIgnoreCaseASCII(theLHS, length(theLHS), theRHS, length(theRHS));
01715 }
01716 
01717 
01718 
01734 inline int
01735 compareIgnoreCaseASCII(
01736             const XalanDOMString&   theLHS,
01737             const XalanDOMString&   theRHS)
01738 {
01739     return compareIgnoreCaseASCII(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
01740 }
01741 
01742 
01743 
01757 inline int
01758 compareIgnoreCaseASCII(
01759             const XalanDOMString&   theLHS,
01760             const XalanDOMChar*     theRHS)
01761 {
01762     return compareIgnoreCaseASCII(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
01763 }
01764 
01765 
01766 
01780 inline int
01781 compareIgnoreCaseASCII(
01782             const XalanDOMChar*     theLHS,
01783             const XalanDOMString&   theRHS)
01784 {
01785     return compareIgnoreCaseASCII(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
01786 }
01787 
01788 
01789 
01800 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
01801 collationCompare(
01802             const XalanDOMChar*         theLHS,
01803             XalanDOMString::size_type   theLHSLength,
01804             const XalanDOMChar*         theRHS,
01805             XalanDOMString::size_type   theRHSLength);
01806 
01807  
01808  
01819 inline int
01820 collationCompare(
01821             const XalanDOMChar*     theLHS,
01822             const XalanDOMChar*     theRHS)
01823 {
01824     return collationCompare(theLHS, length(theLHS), theRHS, length(theRHS));
01825 }
01826 
01827 
01828 
01839 inline int
01840 collationCompare(
01841             const XalanDOMString&   theLHS,
01842             const XalanDOMString&   theRHS)
01843 {
01844     return collationCompare(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
01845 }
01846 
01847 
01848 
01857 inline int
01858 collationCompare(
01859             const XalanDOMChar*     theLHS,
01860             const XalanDOMString&   theRHS)
01861 {
01862     return collationCompare(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
01863 }
01864 
01865 
01866 
01875 inline int
01876 collationCompare(
01877             const XalanDOMString&   theLHS,
01878             const XalanDOMChar*     theRHS)
01879 {
01880     return collationCompare(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
01881 }
01882 
01883 
01884 
01893 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
01894 equals(
01895             const XalanDOMChar*         theLHS,
01896             const XalanDOMChar*         theRHS,
01897             XalanDOMString::size_type   theLength);
01898 
01899 
01900 
01910 inline bool
01911 equals(
01912             const XalanDOMChar*         theLHS,
01913             XalanDOMString::size_type   theLHSLength,
01914             const XalanDOMChar*         theRHS,
01915             XalanDOMString::size_type   theRHSLength)
01916 {
01917     return theLHSLength != theRHSLength ? false : equals(theLHS, theRHS, theLHSLength);
01918 }
01919 
01920 
01921 
01929 inline bool
01930 equals(
01931             const XalanDOMChar*     theLHS,
01932             const XalanDOMChar*     theRHS)
01933 {
01934     const XalanDOMString::size_type     theLHSLength = length(theLHS);
01935 
01936     return theLHSLength != length(theRHS) ? false : equals(theLHS, theRHS, theLHSLength);
01937 }
01938 
01939 
01940 
01948 inline bool
01949 equals(
01950             const XalanDOMString&   theLHS,
01951             const XalanDOMString&   theRHS)
01952 {
01953     return theLHS == theRHS;
01954 }
01955 
01956 
01957 
01965 inline bool
01966 equals(
01967             const XalanDOMChar*     theLHS,
01968             const XalanDOMString&   theRHS)
01969 {
01970     assert(theLHS != 0);
01971 
01972     // Swap them...
01973     return theRHS == theLHS;
01974 }
01975 
01976 
01977 
01985 inline bool
01986 equals(const XalanDOMString&    theLHS,
01987        const XalanDOMChar*      theRHS)
01988 {
01989     return equals(theRHS, theLHS);
01990 }
01991 
01992 
01993 
02002 inline bool
02003 equals(
02004             const XalanDOMString&       theLHS,
02005             const XalanDOMChar*         theRHS,
02006             XalanDOMString::size_type   theRHSLength)
02007 {
02008     return theRHSLength != length(theLHS) ? false : equals(c_wstr(theLHS), theRHSLength, theRHS, theRHSLength);
02009 }
02010 
02011 
02012 
02020 inline bool
02021 equals(const XalanDOMString&    theLHS,
02022        const char*              theRHS)
02023 {
02024     assert(theRHS != 0);
02025 
02026     const XalanDOMString::size_type     theRHSLength = length(theRHS);
02027 
02028     if (theRHSLength != length(theLHS))
02029     {
02030         return false;
02031     }
02032     else
02033     {
02034         return theLHS == XalanDOMString(theRHS, theRHSLength);
02035     }
02036 }
02037 
02038 
02039 
02047 inline bool
02048 equals(const char*              theLHS,
02049        const XalanDOMString&    theRHS)
02050 {
02051     return equals(theRHS, theLHS);
02052 }
02053 
02054 
02055 
02063 inline bool
02064 equals(const XalanDOMChar*  theLHS,
02065        const char*          theRHS)
02066 {
02067     assert(theLHS != 0);
02068     assert(theRHS != 0);
02069 
02070     const XalanDOMString::size_type     theRHSLength = length(theRHS);
02071 
02072     if (theRHSLength != length(theLHS))
02073     {
02074         return false;
02075     }
02076     else
02077     {
02078         return equals(XalanDOMString(theRHS, theRHSLength), theLHS);
02079     }
02080 }
02081 
02082 
02083 
02091 inline bool
02092 equals(const char*          theLHS,
02093        const XalanDOMChar*  theRHS)
02094 {
02095     return equals(theRHS, theLHS);
02096 }
02097 
02098 
02099 
02108 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
02109 equalsIgnoreCaseASCII(
02110             const XalanDOMChar*         theLHS,
02111             const XalanDOMChar*         theRHS,
02112             XalanDOMString::size_type   theLength);
02113 
02114 
02115 
02126 inline bool
02127 equalsIgnoreCaseASCII(
02128             const XalanDOMChar*         theLHS,
02129             XalanDOMString::size_type   theLHSLength,
02130             const XalanDOMChar*         theRHS,
02131             XalanDOMString::size_type   theRHSLength)
02132 {
02133     return theLHSLength != theRHSLength ? false :
02134         equalsIgnoreCaseASCII(theLHS, theRHS, theLHSLength);
02135 }
02136 
02137 
02138 
02147 inline bool
02148 equalsIgnoreCaseASCII(
02149             const XalanDOMChar*     theLHS,
02150             const XalanDOMChar*     theRHS)
02151 {
02152     const XalanDOMString::size_type     theLength = length(theLHS);
02153 
02154     return theLength != length(theRHS) ? false :
02155         equalsIgnoreCaseASCII(theLHS, theRHS, theLength);
02156 }
02157 
02158 
02159 
02168 inline bool
02169 equalsIgnoreCaseASCII(
02170             const XalanDOMString&   theLHS,
02171             const XalanDOMString&   theRHS)
02172 {
02173     const XalanDOMString::size_type     theLength = length(theLHS);
02174 
02175     return theLength != length(theRHS) ? false :
02176         equalsIgnoreCaseASCII(toCharArray(theLHS), toCharArray(theRHS), theLength);
02177 }
02178 
02179 
02180 
02189 inline bool
02190 equalsIgnoreCaseASCII(
02191             const XalanDOMChar*     theLHS,
02192             const XalanDOMString&   theRHS)
02193 {
02194     const XalanDOMString::size_type     theRHSLength = length(theRHS);
02195 
02196     return theRHSLength != length(theLHS) ? false :
02197         equalsIgnoreCaseASCII(theLHS, toCharArray(theRHS), theRHSLength);
02198 }
02199 
02200 
02201 
02210 inline bool
02211 equalsIgnoreCaseASCII(
02212             const XalanDOMString&   theLHS,
02213             const XalanDOMChar*     theRHS)
02214 {
02215     return equalsIgnoreCaseASCII(theRHS, theLHS);
02216 }
02217 
02218 
02219 
02229 inline bool
02230 operator<(
02231             const CharVectorType&   theLHS,
02232             const CharVectorType&   theRHS)
02233 {
02234     return compare(theLHS, theRHS) < 0 ? true : false;
02235 }
02236 
02237 
02238 
02248 inline bool
02249 operator<(
02250             const XalanDOMString&   theLHS,
02251             const XalanDOMString&   theRHS)
02252 {
02253     return compare(theLHS, theRHS) < 0 ? true : false;
02254 }
02255 
02256 
02257 
02266 inline XalanDOMString&
02267 assign(
02268             XalanDOMString&         theString,
02269             const XalanDOMString&   theStringToAssign)
02270 {
02271     theString = theStringToAssign;
02272 
02273     return theString;
02274 }
02275 
02276 
02277 
02286 inline XalanDOMString&
02287 assign(
02288             XalanDOMString&             theString,
02289             const XalanDOMChar*         theStringToAssign,
02290             XalanDOMString::size_type   theStringToAssignLength = XalanDOMString::npos)
02291 {
02292     if (theStringToAssignLength == XalanDOMString::npos)
02293     {
02294         theString.assign(theStringToAssign);
02295     }
02296     else
02297     {
02298         theString.assign(theStringToAssign, theStringToAssignLength);
02299     }
02300 
02301     return theString;
02302 }
02303 
02304 
02305 
02313 inline XalanDOMString&
02314 append(
02315             XalanDOMString&         theString,
02316             const XalanDOMString&   theStringToAppend)
02317 {
02318     theString.append(theStringToAppend);
02319 
02320     return theString;
02321 }
02322 
02323 
02324 
02333 inline XalanDOMString&
02334 append(
02335             XalanDOMString&             theString,
02336             const XalanDOMChar*         theStringToAppend,
02337             XalanDOMString::size_type   theStringToAppendLength = XalanDOMString::npos)
02338 {
02339     assert(theStringToAppend != 0);
02340 
02341     if (theStringToAppendLength == XalanDOMString::npos)
02342     {
02343         theString.append(theStringToAppend);
02344     }
02345     else
02346     {
02347         theString.append(theStringToAppend, theStringToAppendLength);
02348     }
02349 
02350     return theString;
02351 }
02352 
02353 
02354 
02363 inline XalanDOMString&
02364 append(
02365             XalanDOMString&             theString,
02366             const char*                 theStringToAppend,
02367             XalanDOMString::size_type   theStringToAppendLength = XalanDOMString::npos)
02368 {
02369     theString.append(TranscodeFromLocalCodePage(theStringToAppend, theStringToAppendLength));
02370 
02371     return theString;
02372 }
02373 
02374 
02375 
02383 inline XalanDOMString&
02384 append(
02385             XalanDOMString&     theString,
02386             const XalanDOMChar  theCharToAppend)
02387 {
02388     theString.append(1, theCharToAppend);
02389 
02390     return theString;
02391 }
02392 
02393 
02394 
02402 inline XalanDOMString&
02403 append(
02404             XalanDOMString&     theString,
02405             char                theCharToAppend)
02406 {
02407     // We have to transcode before appending...
02408     char    theTempBuffer[] = { theCharToAppend, '\0' };
02409 
02410     return append(theString, theTempBuffer);
02411 }
02412 
02413 
02414 
02423 inline XalanDOMString&
02424 insert(
02425             XalanDOMString&             theString,
02426             XalanDOMString::size_type   thePosition,
02427             const XalanDOMString&       theStringToInsert)
02428 {
02429     theString.insert(thePosition, theStringToInsert);
02430 
02431     return theString;
02432 }
02433 
02434 
02435 
02444 inline XalanDOMString&
02445 insert(
02446             XalanDOMString&             theString,
02447             XalanDOMString::size_type   thePosition,
02448             const XalanDOMChar*         theStringToInsert)
02449 {
02450     theString.insert(thePosition, theStringToInsert);
02451 
02452     return theString;
02453 }
02454 
02455 
02456 
02463 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
02464 trim(const XalanDOMString&  theString);
02465 
02466 
02467 
02473 inline void
02474 clear(XalanDOMString&   theString)
02475 {
02476     theString.clear();
02477 }
02478 
02479 
02480 
02486 inline void
02487 erase(XalanDOMString&   theString)
02488 {
02489     theString.erase();
02490 }
02491 
02492 
02493 
02500 inline void
02501 releaseMemory(XalanDOMString&   theString)
02502 {
02503     XalanDOMString().swap(theString);
02504 }
02505 
02506 
02507 
02508 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
02509 CopyWideStringToVector(
02510             const XalanDOMChar*     theString,
02511             CharVectorType&         theVector);
02512 
02513 
02514 
02515 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
02516 CopyStringToVector(
02517             const char*         theString,
02518             CharVectorType&     theVector);
02519 
02520 
02521 
02530 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMCharVectorType)
02531 MakeXalanDOMCharVector(
02532             const char*     data,
02533             bool            fTranscode = true);
02534 
02535 
02536 
02544 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMCharVectorType)
02545 MakeXalanDOMCharVector(const XalanDOMChar*  data);
02546 
02547 
02548 
02556 inline XalanDOMCharVectorType
02557 MakeXalanDOMCharVector(const XalanDOMString&    data)
02558 {
02559     return MakeXalanDOMCharVector(c_wstr(data));
02560 }
02561 
02562 
02563 
02564 #if defined(XALAN_NO_STD_NAMESPACE)
02565 struct c_wstr_functor : public unary_function<XalanDOMString, const XalanDOMChar*>
02566 #else
02567 struct c_wstr_functor : public std::unary_function<XalanDOMString, const XalanDOMChar*>
02568 #endif
02569 {
02570     result_type
02571 	operator() (const argument_type&   theString) const
02572     {
02573         return c_wstr(theString);
02574     }
02575 };
02576 
02577 
02578 
02585 #if defined(XALAN_NO_STD_NAMESPACE)
02586 struct DOMStringHashFunction : public unary_function<const XalanDOMString&, size_t>
02587 #else
02588 struct DOMStringHashFunction : public std::unary_function<const XalanDOMString&, size_t>
02589 #endif
02590 {
02591     result_type
02592 	operator() (argument_type  theKey) const
02593     {
02594         const XalanDOMChar*     theRawBuffer = c_wstr(theKey);
02595 
02596         result_type     theHashValue = 0; 
02597 
02598         if (theRawBuffer != 0)
02599         {
02600             while (*theRawBuffer)
02601             {
02602                 theHashValue = 5 * theHashValue + *theRawBuffer;
02603 
02604                 theRawBuffer++;
02605             }
02606         }
02607 
02608         return theHashValue++;
02609     }
02610 };
02611 
02612 
02613 
02621 #if defined(XALAN_NO_STD_NAMESPACE)
02622 struct DOMStringEqualsFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02623 #else
02624 struct DOMStringEqualsFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02625 #endif
02626 {
02627     result_type
02628 	operator() (first_argument_type        theLHS,
02629                 second_argument_type    theRHS) const
02630     {
02631         return equals(theLHS, theRHS);
02632     }
02633 };
02634 
02635 
02636 
02644 #if defined(XALAN_NO_STD_NAMESPACE)
02645 struct DOMStringNotEqualsFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02646 #else
02647 struct DOMStringNotEqualsFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02648 #endif
02649 {
02650     result_type
02651 	operator() (first_argument_type        theLHS,
02652                 second_argument_type    theRHS) const
02653     {
02654         return !equals(theLHS, theRHS);
02655     }
02656 };
02657 
02658 
02659 
02667 #if defined(XALAN_NO_STD_NAMESPACE)
02668 struct DOMStringLessThanFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02669 #else
02670 struct DOMStringLessThanFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02671 #endif
02672 {
02673     result_type
02674 	operator() (first_argument_type        theLHS,
02675                 second_argument_type    theRHS) const
02676     {
02677         return compare(theLHS, theRHS) < 0 ? true : false;
02678     }
02679 };
02680 
02681 
02682 
02690 #if defined(XALAN_NO_STD_NAMESPACE)
02691 struct DOMStringPointerLessThanFunction : public binary_function<const XalanDOMString*, const XalanDOMString*, bool>
02692 #else
02693 struct DOMStringPointerLessThanFunction : public std::binary_function<const XalanDOMString*, const XalanDOMString*, bool>
02694 #endif
02695 {
02696     result_type
02697 	operator() (first_argument_type        theLHS,
02698                 second_argument_type    theRHS) const
02699     {
02700         assert(theLHS != 0 && theRHS != 0);
02701 
02702         return compare(*theLHS, *theRHS) < 0 ? true : false;
02703     }
02704 };
02705 
02706 
02707 
02715 #if defined(XALAN_NO_STD_NAMESPACE)
02716 struct DOMStringLessThanIgnoreCaseASCIIFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02717 #else
02718 struct DOMStringLessThanIgnoreCaseASCIIFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02719 #endif
02720 {
02721     result_type
02722 	operator() (first_argument_type        theLHS,
02723                 second_argument_type    theRHS) const
02724     {
02725         return compareIgnoreCaseASCII(theLHS, theRHS) < 0 ? true : false;
02726     }
02727 };
02728 
02729 
02730 
02738 #if defined(XALAN_NO_STD_NAMESPACE)
02739 struct DOMStringLessThanOrEqualFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02740 #else
02741 struct DOMStringLessThanOrEqualFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02742 #endif
02743 {
02744     result_type
02745 	operator() (first_argument_type        theLHS,
02746                 second_argument_type    theRHS) const
02747     {
02748         return compare(theLHS, theRHS) <= 0 ? true : false;
02749     }
02750 };
02751 
02752 
02753 
02761 #if defined(XALAN_NO_STD_NAMESPACE)
02762 struct DOMStringGreaterThanFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02763 #else
02764 struct DOMStringGreaterThanFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02765 #endif
02766 {
02767     result_type
02768 	operator() (first_argument_type        theLHS,
02769                 second_argument_type    theRHS) const
02770     {
02771         return compare(theLHS, theRHS) > 0 ? true : false;
02772     }
02773 };
02774 
02775 
02776 
02784 #if defined(XALAN_NO_STD_NAMESPACE)
02785 struct DOMStringGreaterThanOrEqualFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02786 #else
02787 struct DOMStringGreaterThanOrEqualFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
02788 #endif
02789 {
02790     result_type
02791 	operator() (first_argument_type        theLHS,
02792                 second_argument_type    theRHS) const
02793     {
02794         return compare(theLHS, theRHS) >= 0 ? true : false;
02795     }
02796 };
02797 
02798 
02799 
02805 #if defined(XALAN_NO_STD_NAMESPACE)
02806 struct less_no_case_ascii_wide_string : public binary_function<const XalanDOMChar*, const XalanDOMChar*, bool>
02807 #else
02808 struct less_no_case_ascii_wide_string : public std::binary_function<const XalanDOMChar*, const XalanDOMChar*, bool>
02809 #endif
02810 {
02819     result_type
02820 	operator()(
02821             first_argument_type     theLHS,
02822             second_argument_type    theRHS) const
02823     {
02824         return compareIgnoreCaseASCII(theLHS, theRHS) < 0 ? true : false;
02825     }
02826 };
02827 
02828 
02829 
02836 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
02837 isXMLWhitespace(const XalanDOMString&   string);
02838 
02839 
02840 
02849 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
02850 isXMLWhitespace(
02851             const XalanDOMChar          ch[],
02852             XalanDOMString::size_type   start,
02853             XalanDOMString::size_type   length);
02854 
02855 
02856 
02863 inline bool
02864 isXMLWhitespace(const XalanDOMChar*     theString)
02865 {
02866     assert(theString != 0);
02867 
02868     return isXMLWhitespace(theString, 0, length(theString));
02869 }
02870 
02871 
02872 
02873 XALAN_CPP_NAMESPACE_END
02874 
02875 
02876 
02877 #endif  // DOMSTRINGHELPER_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.7
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.