## Xalan-C++ API Documentation

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

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

# 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                     XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
    00083                     theBuffer,
    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                     XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
    00150                     theBuffer,
    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(MemoryManagerType&  theManager, int   /* theDummy */) :
    00180         Function(),
    00181         m_space(theManager)
    00182     {
    00183     }
    00184
    00185     XalanEXSLTFunctionPadding(const XalanEXSLTFunctionPadding& other, MemoryManagerType&  theManager) :
    00186         Function(other),
    00187         m_space(s_spaceString, theManager)
    00188     {
    00189     }
    00190
    00191     virtual
    00192     ~XalanEXSLTFunctionPadding()
    00193     {
    00194     }
    00195
    00196     // These methods are inherited from Function ...
    00197
    00198     virtual XObjectPtr
    00199     execute(
    00200             XPathExecutionContext&          executionContext,
    00201             XalanNode*                      context,
    00202             const XObjectArgVectorType&     args,
    00203             const LocatorType*              locator) const;
    00204
    00205 #if !defined(XALAN_NO_USING_DECLARATION)
    00206     using ParentType::execute;
    00207 #endif
    00208
    00209 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00210     virtual Function*
    00211 #else
    00212     virtual XalanEXSLTFunctionPadding*
    00213 #endif
    00214     clone(MemoryManagerType&    theManager) const
    00215     {
    00216         return XalanCopyConstruct(theManager, *this, theManager);
    00217     }
    00218
    00219 protected:
    00220
    00221     const XalanDOMString&
    00222     getError(XalanDOMString&    theBuffer) const
    00223     {
    00224         return XalanMessageLoader::getMessage(
    00225                     XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
    00226                     theBuffer,
    00227                     "padding()");
    00228     }
    00229
    00230 private:
    00231
    00232     // Not implemented...
    00233     XalanEXSLTFunctionPadding(const XalanEXSLTFunctionPadding&);
    00234
    00235     XalanEXSLTFunctionPadding&
    00236     operator=(const XalanEXSLTFunctionPadding&);
    00237
    00238     bool
    00239     operator==(const XalanEXSLTFunctionPadding&) const;
    00240
    00241
    00242     // Data members...
    00243     const XalanDOMString        m_space;
    00244
    00245     static const XalanDOMChar   s_spaceString[];
    00246 };
    00247
    00248
    00249 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionEncodeURI : public Function
    00250 {
    00251 public:
    00252
    00253     typedef Function    ParentType;
    00254
    00255     XalanEXSLTFunctionEncodeURI() :
    00256         Function()
    00257     {
    00258     }
    00259
    00260     virtual
    00261     ~XalanEXSLTFunctionEncodeURI()
    00262     {
    00263     }
    00264
    00265     // These methods are inherited from Function ...
    00266
    00267     virtual XObjectPtr
    00268     execute(
    00269             XPathExecutionContext&          executionContext,
    00270             XalanNode*                      context,
    00271             const XObjectArgVectorType&     args,
    00272             const LocatorType*              locator) const;
    00273
    00274 #if !defined(XALAN_NO_USING_DECLARATION)
    00275     using ParentType::execute;
    00276 #endif
    00277
    00278 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00279     virtual Function*
    00280 #else
    00281     virtual XalanEXSLTFunctionEncodeURI*
    00282 #endif
    00283     clone(MemoryManagerType&    theManager) const
    00284     {
    00285         return XalanCopyConstruct(theManager, *this);
    00286     }
    00287
    00288 protected:
    00289
    00290     const XalanDOMString&
    00291     getError(XalanDOMString&    theBuffer) const
    00292     {
    00293         return XalanMessageLoader::getMessage(
    00294                     XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
    00295                     theBuffer,
    00296                     "encode-uri()");
    00297     }
    00298
    00299     const XalanDOMString&
    00300     escapedOctet(
    00301                 XalanDOMChar        theChar,
    00302                 XalanDOMString&     theBuffer) const;
    00303
    00304     static const XalanDOMChar               s_reservedChars[];
    00305     static const XalanDOMString::size_type  s_reservedCharsSize;
    00306
    00307     static const XalanDOMChar               s_excludedChars[];
    00308     static const XalanDOMString::size_type  s_excludedCharsSize;
    00309
    00310 private:
    00311
    00312     // Not implemented...
    00313     XalanEXSLTFunctionEncodeURI&
    00314     operator=(const XalanEXSLTFunctionEncodeURI&);
    00315
    00316     bool
    00317     operator==(const XalanEXSLTFunctionEncodeURI&) const;
    00318 };
    00319
    00320
    00321
    00322 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDecodeURI : public Function
    00323 {
    00324 public:
    00325
    00326     typedef Function    ParentType;
    00327
    00328     XalanEXSLTFunctionDecodeURI() :
    00329         Function()
    00330     {
    00331     }
    00332
    00333     virtual
    00334     ~XalanEXSLTFunctionDecodeURI()
    00335     {
    00336     }
    00337
    00338     // These methods are inherited from Function ...
    00339
    00340     virtual XObjectPtr
    00341     execute(
    00342             XPathExecutionContext&          executionContext,
    00343             XalanNode*                      context,
    00344             const XObjectArgVectorType&     args,
    00345             const LocatorType*              locator) const;
    00346
    00347 #if !defined(XALAN_NO_USING_DECLARATION)
    00348     using ParentType::execute;
    00349 #endif
    00350
    00351 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00352     virtual Function*
    00353 #else
    00354     virtual XalanEXSLTFunctionDecodeURI*
    00355 #endif
    00356     clone(MemoryManagerType&    theManager) const
    00357     {
    00358         return XalanCopyConstruct(theManager, *this);
    00359     }
    00360
    00361 protected:
    00362
    00363     const XalanDOMString&
    00364     getError(XalanDOMString&    theBuffer) const
    00365     {
    00366         return XalanMessageLoader::getMessage(
    00367                     XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
    00368                     theBuffer,
    00369                     "decode-uri()");
    00370
    00371     }
    00372
    00373     XalanDOMChar
    00374     hexCharsToByte(
    00375             XPathExecutionContext&      executionContext,
    00376             XalanNode*                  context,
    00377             const LocatorType*          locator,
    00378             const XalanDOMChar          highHexChar,
    00379             const XalanDOMChar          lowHexChar) const;
    00380
    00381     static const XalanDOMString::size_type s_octetSize;
    00382
    00383 private:
    00384
    00385     // Not implemented...
    00386     XalanEXSLTFunctionDecodeURI&
    00387     operator=(const XalanEXSLTFunctionDecodeURI&);
    00388
    00389     bool
    00390     operator==(const XalanEXSLTFunctionDecodeURI&) const;
    00391 };
    00392
    00393 XALAN_CPP_NAMESPACE_END
    00394
    00395
    00396
    00397 #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.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.