## 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

# XalanEXSLTStringImpl.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(EXSLT_STRINGIMPL_HEADER_GUARD_1357924680)
    00017 #define EXSLT_STRINGIMPL_HEADER_GUARD_1357924680
    00018
    00019
    00020
    00021 #include "XalanEXSLTDefinitions.hpp"
    00022
    00023
    00024
    00025 #include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
    00026
    00027
    00028
    00029 #include <xalanc/XPath/Function.hpp>
    00030
    00031
    00032
    00033 XALAN_CPP_NAMESPACE_BEGIN
    00034
    00035
    00036
    00037 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAlign : public Function
    00038 {
    00039 public:
    00040
    00041     typedef Function    ParentType;
    00042
    00043     XalanEXSLTFunctionAlign()
    00044     {
    00045     }
    00046
    00047
    00048     virtual
    00049     ~XalanEXSLTFunctionAlign()
    00050     {
    00051     }
    00052
    00053     // These methods are inherited from Function ...
    00054
    00055     virtual XObjectPtr
    00056     execute(
    00057             XPathExecutionContext&          executionContext,
    00058             XalanNode*                      context,
    00059             const XObjectArgVectorType&     args,
    00060             const LocatorType*              locator) const;
    00061
    00062 #if !defined(XALAN_NO_USING_DECLARATION)
    00063     using ParentType::execute;
    00064 #endif
    00065
    00066 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00067     virtual Function*
    00068 #else
    00069     virtual XalanEXSLTFunctionAlign*
    00070 #endif
    00071     clone(MemoryManagerType&    theManager) const
    00072     {
    00073         return XalanCopyConstruct(theManager, *this);
    00074     }
    00075
    00076 protected:
    00077
    00078     const XalanDOMString&
    00079     getError(XalanDOMString&    theBuffer) const
    00080     {
    00081         return XalanMessageLoader::getMessage(
    00082                     theBuffer,
    00083                     XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
    00084                     "align()");
    00085     }
    00086
    00087 private:
    00088
    00089     // Not implemented...
    00090     XalanEXSLTFunctionAlign&
    00091     operator=(const XalanEXSLTFunctionAlign&);
    00092
    00093     bool
    00094     operator==(const XalanEXSLTFunctionAlign&) const;
    00095
    00096
    00097     // Data members...
    00098     static const XalanDOMChar   s_centerString[];
    00099     static const XalanDOMChar   s_rightString[];
    00100 };
    00101
    00102
    00103
    00104 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionConcat : public Function
    00105 {
    00106 public:
    00107
    00108     typedef Function    ParentType;
    00109
    00110     XalanEXSLTFunctionConcat() :
    00111         Function()
    00112     {
    00113     }
    00114
    00115     virtual
    00116     ~XalanEXSLTFunctionConcat()
    00117     {
    00118     }
    00119
    00120     // These methods are inherited from Function ...
    00121
    00122     virtual XObjectPtr
    00123     execute(
    00124             XPathExecutionContext&          executionContext,
    00125             XalanNode*                      context,
    00126             const XObjectArgVectorType&     args,
    00127             const LocatorType*              locator) const;
    00128
    00129 #if !defined(XALAN_NO_USING_DECLARATION)
    00130     using ParentType::execute;
    00131 #endif
    00132
    00133 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00134     virtual Function*
    00135 #else
    00136     virtual XalanEXSLTFunctionConcat*
    00137 #endif
    00138     clone(MemoryManagerType&    theManager) const
    00139     {
    00140         return XalanCopyConstruct(theManager, *this);
    00141     }
    00142
    00143 protected:
    00144
    00145     const XalanDOMString&
    00146     getError(XalanDOMString&    theBuffer) const
    00147     {
    00148         return XalanMessageLoader::getMessage(
    00149                     theBuffer,
    00150                     XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
    00151                     "concat()");
    00152     }
    00153
    00154 private:
    00155
    00156     // Not implemented...
    00157     XalanEXSLTFunctionConcat&
    00158     operator=(const XalanEXSLTFunctionConcat&);
    00159
    00160     bool
    00161     operator==(const XalanEXSLTFunctionConcat&) const;
    00162 };
    00163
    00164
    00165
    00166 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionPadding : public Function
    00167 {
    00168 public:
    00169
    00170     typedef Function    ParentType;
    00171
    00172     XalanEXSLTFunctionPadding(MemoryManagerType&  theManager) :
    00173         Function(),
    00174         m_space(s_spaceString, theManager)
    00175     {
    00176     }
    00177
    00178     // A dummy constructor for use internally.  Do not use this one!!!!
    00179     XalanEXSLTFunctionPadding(
    00180                 MemoryManagerType&  theManager,
    00181                 int                 /* theDummy */) :
    00182         Function(),
    00183         m_space(theManager)
    00184     {
    00185     }
    00186
    00187     XalanEXSLTFunctionPadding(
    00188                 const XalanEXSLTFunctionPadding&    other,
    00189                 MemoryManagerType&                  theManager) :
    00190         Function(other),
    00191         m_space(s_spaceString, theManager)
    00192     {
    00193     }
    00194
    00195     virtual
    00196     ~XalanEXSLTFunctionPadding()
    00197     {
    00198     }
    00199
    00200     // These methods are inherited from Function ...
    00201
    00202     virtual XObjectPtr
    00203     execute(
    00204             XPathExecutionContext&          executionContext,
    00205             XalanNode*                      context,
    00206             const XObjectArgVectorType&     args,
    00207             const LocatorType*              locator) const;
    00208
    00209 #if !defined(XALAN_NO_USING_DECLARATION)
    00210     using ParentType::execute;
    00211 #endif
    00212
    00213 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00214     virtual Function*
    00215 #else
    00216     virtual XalanEXSLTFunctionPadding*
    00217 #endif
    00218     clone(MemoryManagerType&    theManager) const
    00219     {
    00220         return XalanCopyConstruct(theManager, *this, theManager);
    00221     }
    00222
    00223 protected:
    00224
    00225     const XalanDOMString&
    00226     getError(XalanDOMString&    theBuffer) const
    00227     {
    00228         return XalanMessageLoader::getMessage(
    00229                     theBuffer,
    00230                     XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
    00231                     "padding()");
    00232     }
    00233
    00234 private:
    00235
    00236     // Not implemented...
    00237     XalanEXSLTFunctionPadding(const XalanEXSLTFunctionPadding&);
    00238
    00239     XalanEXSLTFunctionPadding&
    00240     operator=(const XalanEXSLTFunctionPadding&);
    00241
    00242     bool
    00243     operator==(const XalanEXSLTFunctionPadding&) const;
    00244
    00245
    00246     // Data members...
    00247     const XalanDOMString        m_space;
    00248
    00249     static const XalanDOMChar   s_spaceString[];
    00250 };
    00251
    00252
    00253 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionEncodeURI : public Function
    00254 {
    00255 public:
    00256
    00257     typedef Function    ParentType;
    00258
    00259     XalanEXSLTFunctionEncodeURI() :
    00260         Function()
    00261     {
    00262     }
    00263
    00264     virtual
    00265     ~XalanEXSLTFunctionEncodeURI()
    00266     {
    00267     }
    00268
    00269     // These methods are inherited from Function ...
    00270
    00271     virtual XObjectPtr
    00272     execute(
    00273             XPathExecutionContext&          executionContext,
    00274             XalanNode*                      context,
    00275             const XObjectArgVectorType&     args,
    00276             const LocatorType*              locator) const;
    00277
    00278 #if !defined(XALAN_NO_USING_DECLARATION)
    00279     using ParentType::execute;
    00280 #endif
    00281
    00282 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00283     virtual Function*
    00284 #else
    00285     virtual XalanEXSLTFunctionEncodeURI*
    00286 #endif
    00287     clone(MemoryManagerType&    theManager) const
    00288     {
    00289         return XalanCopyConstruct(theManager, *this);
    00290     }
    00291
    00292 protected:
    00293
    00294     const XalanDOMString&
    00295     getError(XalanDOMString&    theBuffer) const
    00296     {
    00297         return XalanMessageLoader::getMessage(
    00298                     theBuffer,
    00299                     XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
    00300                     "encode-uri()");
    00301     }
    00302
    00303     const XalanDOMString&
    00304     escapedOctet(
    00305                 XalanDOMChar        theChar,
    00306                 XalanDOMString&     theBuffer) const;
    00307
    00308     static const XalanDOMChar               s_reservedChars[];
    00309     static const XalanDOMString::size_type  s_reservedCharsSize;
    00310
    00311     static const XalanDOMChar               s_excludedChars[];
    00312     static const XalanDOMString::size_type  s_excludedCharsSize;
    00313
    00314 private:
    00315
    00316     // Not implemented...
    00317     XalanEXSLTFunctionEncodeURI&
    00318     operator=(const XalanEXSLTFunctionEncodeURI&);
    00319
    00320     bool
    00321     operator==(const XalanEXSLTFunctionEncodeURI&) const;
    00322 };
    00323
    00324
    00325
    00326 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDecodeURI : public Function
    00327 {
    00328 public:
    00329
    00330     typedef Function    ParentType;
    00331
    00332     XalanEXSLTFunctionDecodeURI() :
    00333         Function()
    00334     {
    00335     }
    00336
    00337     virtual
    00338     ~XalanEXSLTFunctionDecodeURI()
    00339     {
    00340     }
    00341
    00342     // These methods are inherited from Function ...
    00343
    00344     virtual XObjectPtr
    00345     execute(
    00346             XPathExecutionContext&          executionContext,
    00347             XalanNode*                      context,
    00348             const XObjectArgVectorType&     args,
    00349             const LocatorType*              locator) const;
    00350
    00351 #if !defined(XALAN_NO_USING_DECLARATION)
    00352     using ParentType::execute;
    00353 #endif
    00354
    00355 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00356     virtual Function*
    00357 #else
    00358     virtual XalanEXSLTFunctionDecodeURI*
    00359 #endif
    00360     clone(MemoryManagerType&    theManager) const
    00361     {
    00362         return XalanCopyConstruct(theManager, *this);
    00363     }
    00364
    00365 protected:
    00366
    00367     const XalanDOMString&
    00368     getError(XalanDOMString&    theBuffer) const
    00369     {
    00370         return XalanMessageLoader::getMessage(
    00371                     theBuffer,
    00372                     XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
    00373                     "decode-uri()");
    00374
    00375     }
    00376
    00377     XalanDOMChar
    00378     hexCharsToByte(
    00379             XPathExecutionContext&      executionContext,
    00380             XalanNode*                  context,
    00381             const LocatorType*          locator,
    00382             const XalanDOMChar          highHexChar,
    00383             const XalanDOMChar          lowHexChar) const;
    00384
    00385     static const XalanDOMString::size_type s_octetSize;
    00386
    00387 private:
    00388
    00389     // Not implemented...
    00390     XalanEXSLTFunctionDecodeURI&
    00391     operator=(const XalanEXSLTFunctionDecodeURI&);
    00392
    00393     bool
    00394     operator==(const XalanEXSLTFunctionDecodeURI&) const;
    00395 };
    00396
    00397 XALAN_CPP_NAMESPACE_END
    00398
    00399
    00400
    00401 #endif  // EXSLT_STRINGIMPL_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.