Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

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