## Xalan-C++ API Documentation

### The Xalan C++ XSLT Processor Version 1.10

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  * Copyright 1999-2004 The Apache Software Foundation.
    00003  *
    00004  * Licensed under the Apache License, Version 2.0 (the "License");
    00005  * you may not use this file except in compliance with the License.
    00006  * You may obtain a copy of the License at
    00007  *
    00008  *     http://www.apache.org/licenses/LICENSE-2.0
    00009  *
    00010  * Unless required by applicable law or agreed to in writing, software
    00011  * distributed under the License is distributed on an "AS IS" BASIS,
    00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00013  * See the License for the specific language governing permissions and
    00014  * limitations under the License.
    00015  */
    00016 #if !defined(DOMSTRINGHELPER_HEADER_GUARD_1357924680)
    00017 #define DOMSTRINGHELPER_HEADER_GUARD_1357924680
    00018
    00019
    00020
    00021 // Base include file.  Must be first.
    00022 #include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp>
    00023
    00024
    00025
    00026 #include <algorithm>
    00027 #include <cassert>
    00028 #include <functional>
    00029 #if defined(XALAN_CLASSIC_IOSTREAMS)
    00030 class ostream;
    00031 #else
    00032 #include <iosfwd>
    00033 #endif
    00034
    00035
    00036
    00037 #include <xalanc/Include/XalanVector.hpp>
    00038 #include <xalanc/Include/XalanMap.hpp>
    00039 #include <xalanc/Include/XalanMemoryManagement.hpp>
    00040 #include <xalanc/Include/STLHelper.hpp>
    00041
    00042
    00043
    00044 #include <xalanc/XalanDOM/XalanDOMString.hpp>
    00045
    00046
    00047
    00048 #include <xalanc/PlatformSupport/FormatterListener.hpp>
    00049 #include <xalanc/PlatformSupport/XalanUnicode.hpp>
    00050 #include <xalanc/PlatformSupport/XalanXMLChar.hpp>
    00051
    00052
    00053
    00054 XALAN_CPP_NAMESPACE_BEGIN
    00055
    00056
    00057
    00058 XALAN_USING_XERCES(MemoryManager)
    00059
    00060
    00061
    00062 class XalanOutputStream;
    00063
    00064
    00065
    00066 // This macro has been defined to deal with certain C++ compilers which
    00067 // do not create Unicode strings when the "L" string constant prefix is
    00068 // used.  It is meant _only_ for use with static strings.
    00069 #if defined(XALAN_LSTRSUPPORT) && !defined(XALAN_XALANDOMCHAR_USHORT_MISMATCH)
    00070
    00071 #define XALAN_STATIC_UCODE_STRING(str) L##str
    00072
    00073 #else
    00074
    00075 #define XALAN_STATIC_UCODE_STRING(str) str
    00076
    00077 #endif
    00078
    00079
    00080
    00081 #if defined(XALAN_NO_ALGORITHMS_WITH_BUILTINS)
    00082
    00083 template<class InputIteratorType, class OutputIteratorType>
    00084 inline OutputIteratorType
    00085 XalanCopy(
    00086             InputIteratorType   begin,
    00087             InputIteratorType   end,
    00088             OutputIteratorType  iterator)
    00089 {
    00090     for(; begin != end; ++iterator, ++begin)
    00091     {
    00092         *iterator = *begin;
    00093     }
    00094
    00095     return iterator;
    00096 }
    00097
    00098
    00099
    00100 template<class InputIteratorType, class OutputIteratorType, class UnaryFunction>
    00101 inline OutputIteratorType
    00102 XalanTransform(
    00103             InputIteratorType   begin,
    00104             InputIteratorType   end,
    00105             OutputIteratorType  iterator,
    00106             UnaryFunction       function)
    00107 {
    00108     for(; begin != end; ++iterator, ++begin)
    00109     {
    00110         *iterator = function(*begin);
    00111     }
    00112
    00113     return iterator;
    00114 }
    00115
    00116 #else
    00117
    00118 template<class InputIteratorType, class OutputIteratorType>
    00119 inline OutputIteratorType
    00120 XalanCopy(
    00121             InputIteratorType   begin,
    00122             InputIteratorType   end,
    00123             OutputIteratorType  iterator)
    00124 {
    00125     return XALAN_STD_QUALIFIER copy(begin, end, iterator);
    00126 }
    00127
    00128
    00129
    00130 template<class InputIteratorType, class OutputIteratorType, class UnaryFunction>
    00131 inline OutputIteratorType
    00132 XalanTransform(
    00133             InputIteratorType   begin,
    00134             InputIteratorType   end,
    00135             OutputIteratorType  iterator,
    00136             UnaryFunction       function)
    00137 {
    00138     return XALAN_STD_QUALIFIER transform(begin, end, iterator);
    00139 }
    00140
    00141 #endif
    00142
    00143
    00144
    00152 inline const XalanDOMChar*
    00153 c_wstr(const XalanDOMString&    theString)
    00154 {
    00155     return theString.c_str();
    00156 }
    00157
    00158
    00159
    00167 inline const char*
    00168 c_str(const CharVectorType&     theString)
    00169 {
    00170     if (theString.empty() == true)
    00171     {
    00172         return 0;
    00173     }
    00174     else
    00175     {
    00176         const char* const   ptr = &theString[0];
    00177
    00178         assert(ptr[theString.size() - 1] == '\0');
    00179
    00180         return ptr;
    00181     }
    00182 }
    00183
    00184
    00185
    00201 inline const XalanDOMChar*
    00202 c_wstr(const XalanDOMChar*  theString)
    00203 {
    00204     return theString;
    00205 }
    00206
    00207
    00208
    00216 inline const XalanDOMChar*
    00217 toCharArray(const XalanDOMString&   theString)
    00218 {
    00219     return theString.c_str();
    00220 }
    00221
    00222
    00223
    00230 inline const XalanDOMChar*
    00231 toCharArray(const XalanDOMChar*     theString)
    00232 {
    00233     return theString;
    00234 }
    00235
    00236
    00237
    00245 inline const char*
    00246 toCharArray(const CharVectorType&   theString)
    00247 {
    00248     return theString.empty() == true ? 0 : &theString[0];
    00249 }
    00250
    00251
    00252
    00260 inline void
    00261 reserve(
    00262             XalanDOMString&             theString,
    00263             XalanDOMString::size_type   theCount)
    00264 {
    00265     theString.reserve(theCount);
    00266 }
    00267
    00268
    00269
    00276 inline XalanDOMString::size_type
    00277 length(const XalanDOMString&    theString)
    00278 {
    00279     return theString.length();
    00280 }
    00281
    00282
    00283
    00291 inline XalanDOMString::size_type
    00292 length(const XalanDOMChar*  theString)
    00293 {
    00294     assert(theString != 0);
    00295
    00296     const XalanDOMChar*     theBufferPointer = theString;
    00297
    00298     while(*theBufferPointer != 0)
    00299     {
    00300         theBufferPointer++;
    00301     }
    00302
    00303     return XalanDOMString::size_type(theBufferPointer - theString);
    00304 }
    00305
    00306
    00307
    00314 inline XalanDOMString::size_type
    00315 length(const char*  theString)
    00316 {
    00317     assert(theString != 0);
    00318
    00319     return XalanDOMString::length(theString);
    00320 }
    00321
    00322
    00323
    00330 inline bool
    00331 isEmpty(const XalanDOMString&   str)
    00332 {
    00333     return str.empty();
    00334 }
    00335
    00336
    00337
    00347 inline XalanDOMString::size_type
    00348 indexOf(
    00349             const XalanDOMChar*     theString,
    00350             XalanDOMChar            theChar)
    00351 {
    00352     assert(theString != 0);
    00353
    00354     const XalanDOMChar*     thePointer = theString;
    00355
    00356     while(*thePointer != theChar && *thePointer != 0)
    00357     {
    00358         ++thePointer;
    00359     }
    00360
    00361     return XalanDOMString::size_type(thePointer - theString);
    00362 }
    00363
    00364
    00365
    00376 inline XalanDOMString::size_type
    00377 indexOf(
    00378             const XalanDOMChar*         theString,
    00379             XalanDOMString::size_type   theStringLength,
    00380             XalanDOMChar                theChar)
    00381 {
    00382     assert(theString != 0);
    00383
    00384     const XalanDOMChar*         thePointer = theString;
    00385     const XalanDOMChar* const   theEndPointer = theString + theStringLength;
    00386
    00387     while(*thePointer != theChar && thePointer != theEndPointer)
    00388     {
    00389         ++thePointer;
    00390     }
    00391
    00392     return XalanDOMString::size_type(thePointer - theString);
    00393 }
    00394
    00395
    00396
    00406 inline XalanDOMString::size_type
    00407 indexOf(
    00408             const XalanDOMString&   theString,
    00409             XalanDOMChar            theChar)
    00410 {
    00411     return length(theString) == 0 ? 0 : indexOf(c_wstr(theString), theChar);
    00412 }
    00413
    00414
    00415
    00427 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
    00428 indexOf(
    00429             const XalanDOMChar*         theString,
    00430             XalanDOMString::size_type   theStringLength,
    00431             const XalanDOMChar*         theSubstring,
    00432             XalanDOMString::size_type   theSubstringLength);
    00433
    00434
    00435
    00445 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
    00446 indexOf(
    00447             const XalanDOMChar*     theString,
    00448             const XalanDOMChar*     theSubstring);
    00449
    00450
    00451
    00461 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
    00462 indexOf(
    00463             const XalanDOMString&   theString,
    00464             const XalanDOMString&   theSubstring);
    00465
    00466
    00467
    00477
    00478 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
    00479 lastIndexOf(
    00480             const XalanDOMChar*     theString,
    00481             XalanDOMChar            theChar);
    00482
    00483
    00484
    00494 inline XalanDOMString::size_type
    00495 lastIndexOf(
    00496             const XalanDOMString&   theString,
    00497             XalanDOMChar            theChar)
    00498 {
    00499     return lastIndexOf(c_wstr(theString), theChar);
    00500 }
    00501
    00502
    00503
    00513 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    00514 startsWith(
    00515             const XalanDOMChar*         theString,
    00516             XalanDOMString::size_type   theStringLength,
    00517             const XalanDOMChar*         theSubstring,
    00518             XalanDOMString::size_type   theSubstringLength);
    00519
    00520
    00521
    00529 inline bool
    00530 startsWith(
    00531             const XalanDOMChar*     theString,
    00532             const XalanDOMChar*     theSubstring)
    00533 {
    00534     assert(theString != 0 && theSubstring != 0);
    00535
    00536     return startsWith(theString, length(theString), theSubstring, length(theSubstring));
    00537 }
    00538
    00539
    00540
    00548 inline bool
    00549 startsWith(
    00550             const XalanDOMChar*     theString,
    00551             const XalanDOMString&   theSubstring)
    00552 {
    00553     assert(theString != 0);
    00554
    00555     return startsWith(theString, length(theString), c_wstr(theSubstring), length(theSubstring));
    00556 }
    00557
    00558
    00559
    00567 inline bool
    00568 startsWith(
    00569             const XalanDOMString&   theString,
    00570             const XalanDOMChar*     theSubstring)
    00571 {
    00572     assert(theSubstring != 0);
    00573
    00574     return startsWith(c_wstr(theString), length(theString), theSubstring, length(theSubstring));
    00575 }
    00576
    00577
    00578
    00587 inline bool
    00588 startsWith(
    00589             const XalanDOMString&       theString,
    00590             const XalanDOMChar*         theSubstring,
    00591             XalanDOMString::size_type   theSubstringLength)
    00592 {
    00593     assert(theSubstring != 0);
    00594
    00595     return startsWith(c_wstr(theString), length(theString), theSubstring, theSubstringLength);
    00596 }
    00597
    00598
    00599
    00607 inline bool
    00608 startsWith(
    00609             const XalanDOMString&   theString,
    00610             const XalanDOMString&   theSubstring)
    00611 {
    00612     return startsWith(c_wstr(theString), length(theString), c_wstr(theSubstring), length(theSubstring));
    00613 }
    00614
    00615
    00616
    00617
    00618
    00619
    00620
    00628 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    00629 endsWith(
    00630             const XalanDOMChar*         theString,
    00631             XalanDOMString::size_type   theStringLength,
    00632             const XalanDOMChar*         theSubstring,
    00633             XalanDOMString::size_type   theSubstringLength);
    00634
    00635
    00636
    00644 inline bool
    00645 endsWith(
    00646             const XalanDOMChar*     theString,
    00647             const XalanDOMChar*     theSubstring)
    00648 {
    00649     assert(theString != 0 && theSubstring != 0);
    00650
    00651     return endsWith(theString, length(theString), theSubstring, length(theSubstring));
    00652 }
    00653
    00654
    00655
    00663 inline bool
    00664 endsWith(
    00665             const XalanDOMString&   theString,
    00666             const XalanDOMString&   theSubstring)
    00667 {
    00668     return endsWith(c_wstr(theString), length(theString), c_wstr(theSubstring), length(theSubstring));
    00669 }
    00670
    00671
    00672
    00680 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00681 PointerToDOMString(
    00682             const void*         theValue,
    00683             XalanDOMString&     theResult);
    00684
    00685
    00686
    00687
    00688
    00696 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00697 DoubleToDOMString(
    00698             double              theValue,
    00699             XalanDOMString&     theResult);
    00700
    00701
    00702
    00703
    00704 class XALAN_PLATFORMSUPPORT_EXPORT DOMStringHelper
    00705 {
    00706 public:
    00707
    00708     typedef void (FormatterListener::*MemberFunctionPtr)(const XMLCh* const, const unsigned int);
    00709
    00710     static void
    00711     DoubleToCharacters(
    00712             double              theDouble,
    00713             FormatterListener&  formatterListener,
    00714             MemberFunctionPtr   function);
    00715
    00716     static void
    00717     LongToCharacters(
    00718             long                theLong,
    00719             FormatterListener&  formatterListener,
    00720             MemberFunctionPtr   function);
    00721 };
    00722
    00723
    00724
    00733 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00734 LongToHexDOMString(
    00735             long                theValue,
    00736             XalanDOMString&     theResult);
    00737
    00738
    00739
    00740
    00741
    00742
    00751 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00752 UnsignedLongToHexDOMString(
    00753             unsigned long       theValue,
    00754             XalanDOMString&     theResult);
    00755
    00756
    00757
    00765 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00766 LongToDOMString(
    00767             long                theValue,
    00768             XalanDOMString&     theResult);
    00769
    00770
    00771
    00772
    00781 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    00782 UnsignedLongToDOMString(
    00783             unsigned long       theValue,
    00784             XalanDOMString&     theResult);
    00785
    00786
    00787
    00788
    00789
    00796 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
    00797 WideStringToInt(const XalanDOMChar*     theString);
    00798
    00799
    00800
    00807 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(long)
    00808 WideStringToLong(const XalanDOMChar*    theString);
    00809
    00810
    00811
    00818 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(unsigned long)
    00819 WideStringToUnsignedLong(const XalanDOMChar*    theString);
    00820
    00821
    00822
    00830 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(double)
    00831 WideStringToDouble(
    00832             const XalanDOMChar*     theString,
    00833             MemoryManager&          theMemoryManager);
    00834
    00835
    00836
    00843 inline int
    00844 DOMStringToInt(const XalanDOMString&    theString)
    00845 {
    00846     return WideStringToInt(c_wstr(theString));
    00847 }
    00848
    00849
    00850
    00857 inline long
    00858 DOMStringToLong(const XalanDOMString&   theString)
    00859 {
    00860     return WideStringToLong(c_wstr(theString));
    00861 }
    00862
    00863
    00864
    00871 inline unsigned long
    00872 DOMStringToUnsignedLong(const XalanDOMString&   theString)
    00873 {
    00874     return WideStringToUnsignedLong(c_wstr(theString));
    00875 }
    00876
    00877
    00878
    00886 inline double
    00887 DOMStringToDouble(
    00888             const XalanDOMString&   theString,
    00889             MemoryManager&          theMemoryManager)
    00890 {
    00891     return WideStringToDouble(
    00892                 c_wstr(theString),
    00893                 theMemoryManager);
    00894 }
    00895
    00896
    00897
    00905 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    00906 OutputString(
    00907             XalanOutputStream&      theStream,
    00908             const CharVectorType&   theString);
    00909
    00910
    00911
    00919 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    00920 OutputString(
    00921 #if defined(XALAN_NO_STD_NAMESPACE)
    00922             ostream&                theStream,
    00923 #else
    00924             std::ostream&           theStream,
    00925 #endif
    00926             const CharVectorType&   theString);
    00927
    00928
    00929
    00937 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    00938 OutputString(
    00939             XalanOutputStream&      theStream,
    00940             const XalanDOMChar*     theString);
    00941
    00942
    00943
    00951 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    00952 OutputString(
    00953 #if defined(XALAN_NO_STD_NAMESPACE)
    00954             ostream&                theStream,
    00955 #else
    00956             std::ostream&           theStream,
    00957 #endif
    00958             const XalanDOMChar*     theString,
    00959             MemoryManager&          theMemoryManager);
    00960
    00961
    00962
    00970 inline void
    00971 OutputString(
    00972             XalanOutputStream&      theStream,
    00973             const XalanDOMString&   theString)
    00974 {
    00975     if (isEmpty(theString) == false)
    00976     {
    00977         OutputString(
    00978             theStream,
    00979             c_wstr(theString));
    00980     }
    00981 }
    00982
    00983
    00984
    00993 inline void
    00994 OutputString(
    00995 #if defined(XALAN_NO_STD_NAMESPACE)
    00996             ostream&                theStream,
    00997 #else
    00998             std::ostream&           theStream,
    00999 #endif
    01000             const XalanDOMString&   theString,
    01001             MemoryManager&          theMemoryManager)
    01002 {
    01003     OutputString(
    01004         theStream,
    01005         c_wstr(theString),
    01006         theMemoryManager);
    01007 }
    01008
    01009
    01010
    01018 inline XalanOutputStream&
    01019 operator<<(
    01020             XalanOutputStream&      theStream,
    01021             const CharVectorType&   theString)
    01022 {
    01023     OutputString(
    01024         theStream,
    01025         theString);
    01026
    01027     return theStream;
    01028 }
    01029
    01030
    01031
    01039 #if defined(XALAN_NO_STD_NAMESPACE)
    01040 inline ostream&
    01041 operator<<(
    01042             ostream&                theStream,
    01043 #else
    01044 inline std::ostream&
    01045 operator<<(
    01046             std::ostream&           theStream,
    01047 #endif
    01048             const CharVectorType&   theString)
    01049 {
    01050     OutputString(
    01051         theStream,
    01052         theString);
    01053
    01054     return theStream;
    01055 }
    01056
    01057
    01058
    01066 inline XalanOutputStream&
    01067 operator<<(
    01068             XalanOutputStream&      theStream,
    01069             const XalanDOMChar*     theString)
    01070 {
    01071     OutputString(
    01072         theStream,
    01073         theString);
    01074
    01075     return theStream;
    01076 }
    01077
    01078
    01079
    01087 #if defined(XALAN_NO_STD_NAMESPACE)
    01088 inline ostream&
    01089 operator<<(
    01090             ostream&                theStream,
    01091 #else
    01092 inline std::ostream&
    01093 operator<<(
    01094             std::ostream&           theStream,
    01095 #endif
    01096             const XalanDOMChar*     theString)
    01097 {
    01098     OutputString(
    01099         theStream,
    01100         theString,
    01101         XalanMemMgrs::getDefault());
    01102
    01103     return theStream;
    01104 }
    01105
    01106
    01107
    01115 inline XalanOutputStream&
    01116 operator<<(
    01117             XalanOutputStream&      theStream,
    01118             const XalanDOMString&   theString)
    01119 {
    01120     OutputString(theStream,
    01121                  theString);
    01122
    01123     return theStream;
    01124 }
    01125
    01126
    01127
    01135 #if defined(XALAN_NO_STD_NAMESPACE)
    01136 inline ostream&
    01137 operator<<(
    01138             ostream&                theStream,
    01139 #else
    01140 inline std::ostream&
    01141 operator<<(
    01142             std::ostream&           theStream,
    01143 #endif
    01144             const XalanDOMString&   theString)
    01145 {
    01146     OutputString(
    01147         theStream,
    01148         theString,
    01149         XalanMemMgrs::getDefault());
    01150
    01151     return theStream;
    01152 }
    01153
    01154
    01155
    01163 #if defined(XALAN_NO_STD_NAMESPACE)
    01164 inline ostream&
    01165 operator<<(
    01166             ostream&            theStream,
    01167 #else
    01168 inline std::ostream&
    01169 operator<<(
    01170             std::ostream&       theStream,
    01171 #endif
    01172             XalanDOMString&     theString)
    01173 {
    01174     OutputString(
    01175         theStream,
    01176         theString,
    01177         theString.getMemoryManager());
    01178
    01179     return theStream;
    01180 }
    01181
    01182
    01183
    01191 inline XalanDOMChar
    01192 charAt(
    01193             const XalanDOMString&       theString,
    01194             XalanDOMString::size_type   theIndex)
    01195 {
    01196     return theString[theIndex];
    01197 }
    01198
    01199
    01200
    01207 inline bool
    01208 isXMLWhitespace(XalanDOMChar    theChar)
    01209 {
    01210     return XalanXMLChar::isWhitespace(theChar);
    01211 }
    01212
    01213
    01214
    01221 inline bool
    01222 isXMLDigit(XalanDOMChar     theChar)
    01223 {
    01224     return XalanXMLChar::isDigit(theChar);
    01225 }
    01226
    01227
    01228
    01235 inline bool
    01236 isXMLLetterOrDigit(XalanDOMChar     theChar)
    01237 {
    01238     return  XalanXMLChar::isDigit(theChar) ||
    01239             XalanXMLChar::isLetter(theChar);
    01240 }
    01241
    01242
    01243
    01244
    01245
    01246
    01259 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01260 substring(
    01261             const XalanDOMChar*         theString,
    01262             XalanDOMString&             theSubstring,
    01263             XalanDOMString::size_type   theStartIndex,
    01264             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
    01265
    01266
    01267
    01279 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    01280 substring(
    01281             const XalanDOMString&       theString,
    01282             XalanDOMString&             theSubstring,
    01283             XalanDOMString::size_type   theStartIndex,
    01284             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
    01285
    01286
    01287
    01299 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01300 substring(
    01301             const XalanDOMString&       theString,
    01302             XalanDOMString::size_type   theStartIndex,
    01303             XalanDOMString&             theResult,
    01304             XalanDOMString::size_type   theEndIndex = XalanDOMString::npos);
    01305
    01306
    01307
    01316 inline XalanDOMChar
    01317 toLowerASCII(XalanDOMChar   theChar)
    01318 {
    01319     if (theChar >= XalanUnicode::charLetter_A && theChar <= XalanUnicode::charLetter_Z)
    01320     {
    01321         return XalanDOMChar(theChar - (XalanUnicode::charLetter_A - XalanUnicode::charLetter_a));
    01322     }
    01323     else
    01324     {
    01325         return theChar;
    01326     }
    01327 }
    01328
    01329
    01330
    01339 inline XalanDOMChar
    01340 toUpperASCII(XalanDOMChar   theChar)
    01341 {
    01342     if (theChar >= XalanUnicode::charLetter_a && theChar <= XalanUnicode::charLetter_z)
    01343     {
    01344         return XalanDOMChar(theChar + (XalanUnicode::charLetter_A - XalanUnicode::charLetter_a));
    01345     }
    01346     else
    01347     {
    01348         return theChar;
    01349     }
    01350 }
    01351
    01352
    01353
    01363 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01364 toLowerCaseASCII(
    01365             const XalanDOMChar*     theString,
    01366             XalanDOMString&         theResult);
    01367
    01368
    01369
    01379 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01380 toLowerCaseASCII(
    01381             const XalanDOMString&   theString,
    01382             XalanDOMString&         theResult);
    01383
    01384
    01385
    01394 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01395 toLowerCaseASCII(XalanDOMString&    theString);
    01396
    01397
    01398
    01408 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01409 toUpperCaseASCII(
    01410             const XalanDOMChar*     theString,
    01411             XalanDOMString&         theResult);
    01412
    01413
    01414
    01424 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01425 toUpperCaseASCII(
    01426             const XalanDOMString&   theString,
    01427             XalanDOMString&         theResult);
    01428
    01429
    01430
    01439 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    01440 toUpperCaseASCII(XalanDOMString&    theString);
    01441
    01442
    01443
    01456 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
    01457 compare(
    01458             const CharVectorType&   theLHS,
    01459             const CharVectorType&   theRHS);
    01460
    01461
    01462
    01476 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
    01477 compare(
    01478             const XalanDOMChar*         theLHS,
    01479             XalanDOMString::size_type   theLHSLength,
    01480             const XalanDOMChar*         theRHS,
    01481             XalanDOMString::size_type   theRHSLength);
    01482
    01483
    01484
    01496 inline int
    01497 compare(
    01498             const XalanDOMChar*     theLHS,
    01499             const XalanDOMChar*     theRHS)
    01500 {
    01501     return compare(theLHS, length(theLHS), theRHS, length(theRHS));
    01502 }
    01503
    01504
    01505
    01519 inline int
    01520 compare(
    01521             const XalanDOMString&   theLHS,
    01522             const XalanDOMString&   theRHS)
    01523 {
    01524     return compare(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
    01525 }
    01526
    01527
    01528
    01540 inline int
    01541 compare(
    01542             const XalanDOMChar*     theLHS,
    01543             const XalanDOMString&   theRHS)
    01544 {
    01545     return compare(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
    01546 }
    01547
    01548
    01549
    01561 inline int
    01562 compare(
    01563             const XalanDOMString&   theLHS,
    01564             const XalanDOMChar*     theRHS)
    01565 {
    01566     return compare(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
    01567 }
    01568
    01569
    01570
    01586 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
    01587 compareIgnoreCaseASCII(
    01588             const XalanDOMChar*         theLHS,
    01589             XalanDOMString::size_type   theLHSLength,
    01590             const XalanDOMChar*         theRHS,
    01591             XalanDOMString::size_type   theRHSLength);
    01592
    01593
    01594
    01608 inline int
    01609 compareIgnoreCaseASCII(
    01610             const XalanDOMChar*     theLHS,
    01611             const XalanDOMChar*     theRHS)
    01612 {
    01613     return compareIgnoreCaseASCII(theLHS, length(theLHS), theRHS, length(theRHS));
    01614 }
    01615
    01616
    01617
    01633 inline int
    01634 compareIgnoreCaseASCII(
    01635             const XalanDOMString&   theLHS,
    01636             const XalanDOMString&   theRHS)
    01637 {
    01638     return compareIgnoreCaseASCII(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
    01639 }
    01640
    01641
    01642
    01656 inline int
    01657 compareIgnoreCaseASCII(
    01658             const XalanDOMString&   theLHS,
    01659             const XalanDOMChar*     theRHS)
    01660 {
    01661     return compareIgnoreCaseASCII(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
    01662 }
    01663
    01664
    01665
    01679 inline int
    01680 compareIgnoreCaseASCII(
    01681             const XalanDOMChar*     theLHS,
    01682             const XalanDOMString&   theRHS)
    01683 {
    01684     return compareIgnoreCaseASCII(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
    01685 }
    01686
    01687
    01688
    01699 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
    01700 collationCompare(
    01701             const XalanDOMChar*         theLHS,
    01702             XalanDOMString::size_type   theLHSLength,
    01703             const XalanDOMChar*         theRHS,
    01704             XalanDOMString::size_type   theRHSLength);
    01705
    01706
    01707
    01718 inline int
    01719 collationCompare(
    01720             const XalanDOMChar*     theLHS,
    01721             const XalanDOMChar*     theRHS)
    01722 {
    01723     return collationCompare(theLHS, length(theLHS), theRHS, length(theRHS));
    01724 }
    01725
    01726
    01727
    01738 inline int
    01739 collationCompare(
    01740             const XalanDOMString&   theLHS,
    01741             const XalanDOMString&   theRHS)
    01742 {
    01743     return collationCompare(toCharArray(theLHS), length(theLHS), toCharArray(theRHS), length(theRHS));
    01744 }
    01745
    01746
    01747
    01756 inline int
    01757 collationCompare(
    01758             const XalanDOMChar*     theLHS,
    01759             const XalanDOMString&   theRHS)
    01760 {
    01761     return collationCompare(theLHS, length(theLHS), toCharArray(theRHS), length(theRHS));
    01762 }
    01763
    01764
    01765
    01774 inline int
    01775 collationCompare(
    01776             const XalanDOMString&   theLHS,
    01777             const XalanDOMChar*     theRHS)
    01778 {
    01779     return collationCompare(toCharArray(theLHS), length(theLHS), theRHS, length(theRHS));
    01780 }
    01781
    01782
    01783
    01792 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    01793 equals(
    01794             const XalanDOMChar*         theLHS,
    01795             const XalanDOMChar*         theRHS,
    01796             XalanDOMString::size_type   theLength);
    01797
    01798
    01799
    01809 inline bool
    01810 equals(
    01811             const XalanDOMChar*         theLHS,
    01812             XalanDOMString::size_type   theLHSLength,
    01813             const XalanDOMChar*         theRHS,
    01814             XalanDOMString::size_type   theRHSLength)
    01815 {
    01816     return theLHSLength != theRHSLength ? false : equals(theLHS, theRHS, theLHSLength);
    01817 }
    01818
    01819
    01820
    01828 inline bool
    01829 equals(
    01830             const XalanDOMChar*     theLHS,
    01831             const XalanDOMChar*     theRHS)
    01832 {
    01833     const XalanDOMString::size_type     theLHSLength = length(theLHS);
    01834
    01835     return theLHSLength != length(theRHS) ? false : equals(theLHS, theRHS, theLHSLength);
    01836 }
    01837
    01838
    01839
    01847 inline bool
    01848 equals(
    01849             const XalanDOMString&   theLHS,
    01850             const XalanDOMString&   theRHS)
    01851 {
    01852     return theLHS == theRHS;
    01853 }
    01854
    01855
    01856
    01864 inline bool
    01865 equals(
    01866             const XalanDOMChar*     theLHS,
    01867             const XalanDOMString&   theRHS)
    01868 {
    01869     assert(theLHS != 0);
    01870
    01871     // Swap them...
    01872     return theRHS == theLHS;
    01873 }
    01874
    01875
    01876
    01884 inline bool
    01885 equals(const XalanDOMString&    theLHS,
    01886        const XalanDOMChar*      theRHS)
    01887 {
    01888     return equals(theRHS, theLHS);
    01889 }
    01890
    01891
    01892
    01901 inline bool
    01902 equals(
    01903             const XalanDOMString&       theLHS,
    01904             const XalanDOMChar*         theRHS,
    01905             XalanDOMString::size_type   theRHSLength)
    01906 {
    01907     return theRHSLength != length(theLHS) ? false : equals(c_wstr(theLHS), theRHSLength, theRHS, theRHSLength);
    01908 }
    01909
    01910
    01911
    01912
    01921 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    01922 equalsIgnoreCaseASCII(
    01923             const XalanDOMChar*         theLHS,
    01924             const XalanDOMChar*         theRHS,
    01925             XalanDOMString::size_type   theLength);
    01926
    01927
    01928
    01939 inline bool
    01940 equalsIgnoreCaseASCII(
    01941             const XalanDOMChar*         theLHS,
    01942             XalanDOMString::size_type   theLHSLength,
    01943             const XalanDOMChar*         theRHS,
    01944             XalanDOMString::size_type   theRHSLength)
    01945 {
    01946     return theLHSLength != theRHSLength ? false :
    01947         equalsIgnoreCaseASCII(theLHS, theRHS, theLHSLength);
    01948 }
    01949
    01950
    01951
    01960 inline bool
    01961 equalsIgnoreCaseASCII(
    01962             const XalanDOMChar*     theLHS,
    01963             const XalanDOMChar*     theRHS)
    01964 {
    01965     const XalanDOMString::size_type     theLength = length(theLHS);
    01966
    01967     return theLength != length(theRHS) ? false :
    01968         equalsIgnoreCaseASCII(theLHS, theRHS, theLength);
    01969 }
    01970
    01971
    01972
    01981 inline bool
    01982 equalsIgnoreCaseASCII(
    01983             const XalanDOMString&   theLHS,
    01984             const XalanDOMString&   theRHS)
    01985 {
    01986     const XalanDOMString::size_type     theLength = length(theLHS);
    01987
    01988     return theLength != length(theRHS) ? false :
    01989         equalsIgnoreCaseASCII(toCharArray(theLHS), toCharArray(theRHS), theLength);
    01990 }
    01991
    01992
    01993
    02002 inline bool
    02003 equalsIgnoreCaseASCII(
    02004             const XalanDOMChar*     theLHS,
    02005             const XalanDOMString&   theRHS)
    02006 {
    02007     const XalanDOMString::size_type     theRHSLength = length(theRHS);
    02008
    02009     return theRHSLength != length(theLHS) ? false :
    02010         equalsIgnoreCaseASCII(theLHS, toCharArray(theRHS), theRHSLength);
    02011 }
    02012
    02013
    02014
    02023 inline bool
    02024 equalsIgnoreCaseASCII(
    02025             const XalanDOMString&   theLHS,
    02026             const XalanDOMChar*     theRHS)
    02027 {
    02028     return equalsIgnoreCaseASCII(theRHS, theLHS);
    02029 }
    02030
    02031
    02032
    02042 inline bool
    02043 operator<(
    02044             const CharVectorType&   theLHS,
    02045             const CharVectorType&   theRHS)
    02046 {
    02047     return compare(theLHS, theRHS) < 0 ? true : false;
    02048 }
    02049
    02050
    02051
    02061 inline bool
    02062 operator<(
    02063             const XalanDOMString&   theLHS,
    02064             const XalanDOMString&   theRHS)
    02065 {
    02066     return compare(theLHS, theRHS) < 0 ? true : false;
    02067 }
    02068
    02069
    02070
    02079 inline XalanDOMString&
    02080 assign(
    02081             XalanDOMString&         theString,
    02082             const XalanDOMString&   theStringToAssign)
    02083 {
    02084     theString = theStringToAssign;
    02085
    02086     return theString;
    02087 }
    02088
    02089
    02090
    02099 inline XalanDOMString&
    02100 assign(
    02101             XalanDOMString&             theString,
    02102             const XalanDOMChar*         theStringToAssign,
    02103             XalanDOMString::size_type   theStringToAssignLength = XalanDOMString::npos)
    02104 {
    02105     if (theStringToAssignLength == XalanDOMString::npos)
    02106     {
    02107         theString.assign(theStringToAssign);
    02108     }
    02109     else
    02110     {
    02111         theString.assign(theStringToAssign, theStringToAssignLength);
    02112     }
    02113
    02114     return theString;
    02115 }
    02116
    02117
    02118
    02126 inline XalanDOMString&
    02127 append(
    02128             XalanDOMString&         theString,
    02129             const XalanDOMString&   theStringToAppend)
    02130 {
    02131     theString.append(theStringToAppend);
    02132
    02133     return theString;
    02134 }
    02135
    02136
    02137
    02146 inline XalanDOMString&
    02147 append(
    02148             XalanDOMString&             theString,
    02149             const XalanDOMChar*         theStringToAppend,
    02150             XalanDOMString::size_type   theStringToAppendLength = XalanDOMString::npos)
    02151 {
    02152     assert(theStringToAppend != 0);
    02153
    02154     if (theStringToAppendLength == XalanDOMString::npos)
    02155     {
    02156         theString.append(theStringToAppend);
    02157     }
    02158     else
    02159     {
    02160         theString.append(theStringToAppend, theStringToAppendLength);
    02161     }
    02162
    02163     return theString;
    02164 }
    02165
    02166
    02167
    02176 inline XalanDOMString&
    02177 append(
    02178             XalanDOMString&             theString,
    02179             const char*                 theStringToAppend,
    02180             XalanDOMString::size_type   theStringToAppendLength = XalanDOMString::npos)
    02181 {
    02182     XalanDOMString tmp(theString.getMemoryManager());
    02183
    02184     TranscodeFromLocalCodePage(theStringToAppend, tmp, theStringToAppendLength);
    02185
    02186     theString.append(tmp);
    02187
    02188     return theString;
    02189 }
    02190
    02191
    02192
    02200 inline XalanDOMString&
    02201 append(
    02202             XalanDOMString&     theString,
    02203             const XalanDOMChar  theCharToAppend)
    02204 {
    02205     theString.append(1, theCharToAppend);
    02206
    02207     return theString;
    02208 }
    02209
    02210
    02211
    02219 inline XalanDOMString&
    02220 append(
    02221             XalanDOMString&     theString,
    02222             char                theCharToAppend)
    02223 {
    02224     // We have to transcode before appending...
    02225     char    theTempBuffer[] = { theCharToAppend, '\0' };
    02226
    02227     return append(theString, theTempBuffer);
    02228 }
    02229
    02230
    02231
    02240 inline XalanDOMString&
    02241 insert(
    02242             XalanDOMString&             theString,
    02243             XalanDOMString::size_type   thePosition,
    02244             const XalanDOMString&       theStringToInsert)
    02245 {
    02246     theString.insert(thePosition, theStringToInsert);
    02247
    02248     return theString;
    02249 }
    02250
    02251
    02252
    02261 inline XalanDOMString&
    02262 insert(
    02263             XalanDOMString&             theString,
    02264             XalanDOMString::size_type   thePosition,
    02265             const XalanDOMChar*         theStringToInsert)
    02266 {
    02267     theString.insert(thePosition, theStringToInsert);
    02268
    02269     return theString;
    02270 }
    02271
    02272
    02273
    02280 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString&)
    02281 trim(const XalanDOMString&  theString, XalanDOMString& theResult);
    02282
    02283
    02284
    02290 inline void
    02291 clear(XalanDOMString&   theString)
    02292 {
    02293     theString.clear();
    02294 }
    02295
    02296
    02297
    02303 inline void
    02304 erase(XalanDOMString&   theString)
    02305 {
    02306     theString.erase();
    02307 }
    02308
    02309
    02310
    02317 inline void
    02318 releaseMemory(XalanDOMString&   theString,MemoryManagerType&  theManager)
    02319 {
    02320     XalanDOMString(theManager).swap(theString);
    02321 }
    02322
    02323
    02324
    02325 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    02326 CopyWideStringToVector(
    02327             const XalanDOMChar*     theString,
    02328             CharVectorType&         theVector);
    02329
    02330
    02331
    02332 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
    02333 CopyStringToVector(
    02334             const char*         theString,
    02335             CharVectorType&     theVector);
    02336
    02337
    02338
    02347 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMCharVectorType&)
    02348 MakeXalanDOMCharVector(
    02349             const char*     data,
    02350             XalanDOMCharVectorType& result,
    02351             bool            fTranscode = true);
    02352
    02353
    02354
    02362 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMCharVectorType&)
    02363 MakeXalanDOMCharVector(const XalanDOMChar*  data,
    02364                        XalanDOMCharVectorType& result);
    02365
    02366
    02367
    02375 inline XalanDOMCharVectorType&
    02376 MakeXalanDOMCharVector(const XalanDOMString&    data,
    02377                        XalanDOMCharVectorType& result)
    02378 {
    02379     return MakeXalanDOMCharVector(c_wstr(data),result);
    02380 }
    02381
    02382
    02383
    02384 #if defined(XALAN_NO_STD_NAMESPACE)
    02385 struct c_wstr_functor : public unary_function<XalanDOMString, const XalanDOMChar*>
    02386 #else
    02387 struct c_wstr_functor : public std::unary_function<XalanDOMString, const XalanDOMChar*>
    02388 #endif
    02389 {
    02390     result_type
    02391     operator() (const argument_type&    theString) const
    02392     {
    02393         return c_wstr(theString);
    02394     }
    02395 };
    02396
    02397
    02398
    02405 struct DOMStringHashFunction : public XALAN_STD_QUALIFIER unary_function<const XalanDOMString&, size_t>
    02406 {
    02407     result_type
    02408     operator() (argument_type   theKey) const
    02409     {
    02410         const XalanDOMChar*     theRawBuffer = c_wstr(theKey);
    02411
    02412         hash_null_terminated_arrays<XalanDOMChar> hasher;
    02413
    02414         return hasher(theRawBuffer);
    02415     }
    02416 };
    02417
    02418
    02419
    02420 template<>
    02421 struct XalanMapKeyTraits<XalanDOMString>
    02422 {
    02423     typedef DOMStringHashFunction                           Hasher;
    02424     typedef XALAN_STD_QUALIFIER equal_to<XalanDOMString>    Comparator;
    02425 };
    02426
    02427
    02428
    02435 struct DOMStringPointerHashFunction : public XALAN_STD_QUALIFIER unary_function<const XalanDOMString*, size_t>
    02436 {
    02437     result_type
    02438     operator() (argument_type   theKey) const
    02439     {
    02440         assert (theKey != 0);
    02441         return DOMStringHashFunction()(*theKey);
    02442     }
    02443 };
    02444
    02445
    02446
    02447 template<>
    02448 struct XalanMapKeyTraits<XalanDOMString*>
    02449 {
    02450     typedef DOMStringPointerHashFunction    Hasher;
    02451     typedef pointer_equal<XalanDOMString>   Comparator;
    02452 };
    02453
    02454 template<>
    02455 struct XalanMapKeyTraits<const XalanDOMString*>
    02456 {
    02457     typedef DOMStringPointerHashFunction    Hasher;
    02458     typedef pointer_equal<XalanDOMString>   Comparator;
    02459 };
    02460
    02461
    02469 #if defined(XALAN_NO_STD_NAMESPACE)
    02470 struct DOMStringEqualsFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02471 #else
    02472 struct DOMStringEqualsFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02473 #endif
    02474 {
    02475     result_type
    02476     operator() (first_argument_type     theLHS,
    02477                 second_argument_type    theRHS) const
    02478     {
    02479         return equals(theLHS, theRHS);
    02480     }
    02481 };
    02482
    02483
    02484
    02492 #if defined(XALAN_NO_STD_NAMESPACE)
    02493 struct DOMStringNotEqualsFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02494 #else
    02495 struct DOMStringNotEqualsFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02496 #endif
    02497 {
    02498     result_type
    02499     operator() (first_argument_type     theLHS,
    02500                 second_argument_type    theRHS) const
    02501     {
    02502         return !equals(theLHS, theRHS);
    02503     }
    02504 };
    02505
    02506
    02507
    02515 #if defined(XALAN_NO_STD_NAMESPACE)
    02516 struct DOMStringLessThanFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02517 #else
    02518 struct DOMStringLessThanFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02519 #endif
    02520 {
    02521     result_type
    02522     operator() (first_argument_type     theLHS,
    02523                 second_argument_type    theRHS) const
    02524     {
    02525         return compare(theLHS, theRHS) < 0 ? true : false;
    02526     }
    02527 };
    02528
    02529
    02537 struct DOMStringPointerEqualToFunction : public XALAN_STD_QUALIFIER binary_function<const XalanDOMString*, const XalanDOMString*, bool>
    02538 {
    02539     result_type
    02540     operator() (first_argument_type     theLHS,
    02541                 second_argument_type    theRHS) const
    02542     {
    02543         assert(theLHS != 0 && theRHS != 0);
    02544
    02545         return compare(*theLHS, *theRHS) == 0 ? true : false;
    02546     }
    02547 };
    02548
    02549
    02557 #if defined(XALAN_NO_STD_NAMESPACE)
    02558 struct DOMStringPointerLessThanFunction : public binary_function<const XalanDOMString*, const XalanDOMString*, bool>
    02559 #else
    02560 struct DOMStringPointerLessThanFunction : public std::binary_function<const XalanDOMString*, const XalanDOMString*, bool>
    02561 #endif
    02562 {
    02563     result_type
    02564     operator() (first_argument_type     theLHS,
    02565                 second_argument_type    theRHS) const
    02566     {
    02567         assert(theLHS != 0 && theRHS != 0);
    02568
    02569         return compare(*theLHS, *theRHS) < 0 ? true : false;
    02570     }
    02571 };
    02572
    02573
    02574
    02582 #if defined(XALAN_NO_STD_NAMESPACE)
    02583 struct DOMStringLessThanIgnoreCaseASCIIFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02584 #else
    02585 struct DOMStringLessThanIgnoreCaseASCIIFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02586 #endif
    02587 {
    02588     result_type
    02589     operator() (first_argument_type     theLHS,
    02590                 second_argument_type    theRHS) const
    02591     {
    02592         return compareIgnoreCaseASCII(theLHS, theRHS) < 0 ? true : false;
    02593     }
    02594 };
    02595
    02596
    02597
    02605 #if defined(XALAN_NO_STD_NAMESPACE)
    02606 struct DOMStringLessThanOrEqualFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02607 #else
    02608 struct DOMStringLessThanOrEqualFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02609 #endif
    02610 {
    02611     result_type
    02612     operator() (first_argument_type     theLHS,
    02613                 second_argument_type    theRHS) const
    02614     {
    02615         return compare(theLHS, theRHS) <= 0 ? true : false;
    02616     }
    02617 };
    02618
    02619
    02620
    02628 #if defined(XALAN_NO_STD_NAMESPACE)
    02629 struct DOMStringGreaterThanFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02630 #else
    02631 struct DOMStringGreaterThanFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02632 #endif
    02633 {
    02634     result_type
    02635     operator() (first_argument_type     theLHS,
    02636                 second_argument_type    theRHS) const
    02637     {
    02638         return compare(theLHS, theRHS) > 0 ? true : false;
    02639     }
    02640 };
    02641
    02642
    02643
    02651 #if defined(XALAN_NO_STD_NAMESPACE)
    02652 struct DOMStringGreaterThanOrEqualFunction : public binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02653 #else
    02654 struct DOMStringGreaterThanOrEqualFunction : public std::binary_function<const XalanDOMString&, const XalanDOMString&, bool>
    02655 #endif
    02656 {
    02657     result_type
    02658     operator() (first_argument_type     theLHS,
    02659                 second_argument_type    theRHS) const
    02660     {
    02661         return compare(theLHS, theRHS) >= 0 ? true : false;
    02662     }
    02663 };
    02664
    02665
    02666
    02672 #if defined(XALAN_NO_STD_NAMESPACE)
    02673 struct less_no_case_ascii_wide_string : public binary_function<const XalanDOMChar*, const XalanDOMChar*, bool>
    02674 #else
    02675 struct less_no_case_ascii_wide_string : public std::binary_function<const XalanDOMChar*, const XalanDOMChar*, bool>
    02676 #endif
    02677 {
    02686     result_type
    02687     operator()(
    02688             first_argument_type     theLHS,
    02689             second_argument_type    theRHS) const
    02690     {
    02691         return compareIgnoreCaseASCII(theLHS, theRHS) < 0 ? true : false;
    02692     }
    02693 };
    02694
    02695
    02696
    02703 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    02704 isXMLWhitespace(const XalanDOMString&   string);
    02705
    02706
    02707
    02716 XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
    02717 isXMLWhitespace(
    02718             const XalanDOMChar          ch[],
    02719             XalanDOMString::size_type   start,
    02720             XalanDOMString::size_type   length);
    02721
    02722
    02723
    02730 inline bool
    02731 isXMLWhitespace(const XalanDOMChar*     theString)
    02732 {
    02733     assert(theString != 0);
    02734
    02735     return isXMLWhitespace(theString, 0, length(theString));
    02736 }
    02737
    02738
    02739
    02740 XALAN_CPP_NAMESPACE_END
    02741
    02742
    02743
    02744 #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.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.