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.