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  

XalanQNameByValue.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(XALANQNAMEBYVALUE_HEADER_GUARD_1357924680)
00017 #define XALANQNAMEBYVALUE_HEADER_GUARD_1357924680
00018 
00019 
00020 
00021 // Base header file.  Must be first.
00022 #include <xalanc/XPath/XPathDefinitions.hpp>
00023 
00024 
00025 
00026 // Base class header file...
00027 #include <xalanc/XPath/XalanQName.hpp>
00028 
00029 
00030 
00031 XALAN_DECLARE_XERCES_CLASS(Locator)
00032 
00033 
00034 
00035 XALAN_CPP_NAMESPACE_BEGIN
00036 
00037 
00038 
00039 class DOMSupport;
00040 
00041 
00042 
00043 class XALAN_XPATH_EXPORT XalanQNameByValue : public XalanQName
00044 {
00045 public:
00046 
00047     typedef XERCES_CPP_NAMESPACE_QUALIFIER Locator  LocatorType;
00048 
00052     explicit
00053     XalanQNameByValue(MemoryManagerType& theManager);
00054 
00055     MemoryManagerType&
00056     getMemoryManager()
00057     {
00058         return m_namespace.getMemoryManager();
00059     }
00060 
00066     XalanQNameByValue(const XalanQNameByValue&  theSource,
00067                     MemoryManagerType& theManager);
00068 
00074     explicit
00075     XalanQNameByValue(const XalanQName& theSource,
00076                     MemoryManagerType& theManager);
00077 
00084     XalanQNameByValue(
00085             const XalanDOMString&   theNamespace,
00086             const XalanDOMString&   theLocalPart,
00087             MemoryManagerType&      theManager);
00088 
00089     static XalanQNameByValue*
00090     create(
00091             const XalanDOMString&   theNamespace,
00092             const XalanDOMString&   theLocalPart,
00093             MemoryManagerType&      theManager);
00094 
00104     XalanQNameByValue(
00105             const XalanDOMString&       qname,
00106             const NamespacesStackType&  namespaces,
00107             MemoryManagerType&          theManager,
00108             const LocatorType*          locator = 0,
00109             bool                        fUseDefault = false);
00110 
00120     XalanQNameByValue(
00121             const XalanDOMChar*         qname,
00122             const NamespacesStackType&  namespaces,
00123             MemoryManagerType&          theManager,
00124             const LocatorType*          locator = 0,
00125             bool                        fUseDefault = false);
00126 
00137     XalanQNameByValue(
00138             const XalanDOMString&   qname,
00139             const XalanElement*     namespaceContext,
00140             const XPathEnvSupport&  envSupport,
00141             const DOMSupport&       domSupport,
00142             MemoryManagerType&      theManager,
00143             const LocatorType*      locator = 0);
00144 
00153     XalanQNameByValue(
00154             const XalanDOMString&   qname,
00155             MemoryManagerType&      theManager,
00156             const PrefixResolver*   theResolver = 0,
00157             const LocatorType*      locator = 0);
00158 
00159     virtual
00160     ~XalanQNameByValue();
00161 
00167     virtual const XalanDOMString&
00168     getLocalPart() const;
00169 
00175     void
00176     setLocalPart(const XalanDOMString&  theLocalPart)
00177     {
00178         m_localpart = theLocalPart;
00179     }
00180 
00186     virtual const XalanDOMString&
00187     getNamespace() const;
00188 
00194     void
00195     setNamespace(const XalanDOMString&  theNamespace)
00196     {
00197         m_namespace = theNamespace;
00198     }
00199 
00210     void
00211     set(
00212             const XalanDOMString&       qname,
00213             const NamespacesStackType&  namespaces,
00214             const LocatorType*          locator = 0,
00215             bool                        fUseDefault = false);
00216 
00227     void
00228     set(
00229             const XalanDOMChar*         qname,
00230             const NamespacesStackType&  namespaces,
00231             const LocatorType*          locator = 0,
00232             bool                        fUseDefault = false);
00233 
00243     void
00244     set(
00245             const XalanDOMString&   qname,
00246             const PrefixResolver*   theResolver = 0,
00247             const LocatorType*      locator = 0);
00248 
00258     void
00259     set(
00260             const XalanDOMChar*     qname,
00261             const PrefixResolver*   theResolver = 0,
00262             const LocatorType*      locator = 0);
00266     void
00267     clear()
00268     {
00269         m_namespace.clear();
00270         m_localpart.clear();
00271     }
00272 
00273     XalanQNameByValue&
00274     operator=(const XalanQNameByValue&  theRHS)
00275     {
00276         m_namespace = theRHS.m_namespace;
00277         m_localpart = theRHS.m_localpart;
00278 
00279         return *this;
00280     }
00281 
00282     XalanQNameByValue&
00283     operator=(const XalanQName&     theRHS)
00284     {
00285         m_namespace = theRHS.getNamespace();
00286         m_localpart = theRHS.getLocalPart();
00287 
00288         return *this;
00289     }
00290 
00291 private:
00292     // not implemented
00293     XalanQNameByValue(const XalanQNameByValue&  theSource);
00294     void
00295     initialize(
00296             const XalanDOMChar*         qname,
00297             XalanDOMString::size_type   len,
00298             const NamespacesStackType&  namespaces,
00299             const LocatorType*          locator,
00300             bool                        fUseDefault);
00301 
00302     void
00303     resolvePrefix(
00304             const XalanDOMChar*         qname,
00305             XalanDOMString::size_type   theLength,
00306             const PrefixResolver*       theResolver,
00307             const LocatorType*          locator);
00308 
00309     void
00310     validate(
00311             const XalanDOMChar*         qname,
00312             XalanDOMString::size_type   theLength,
00313             const LocatorType*          locator);
00314 
00315     // Data members...
00316     XalanDOMString  m_namespace;
00317 
00318     XalanDOMString  m_localpart;
00319 };
00320 
00321 
00322 
00323 XALAN_CPP_NAMESPACE_END
00324 
00325 
00326 
00327 #endif  // XALANQNAMEBYVALUE_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

dot

Xalan-C++ XSLT Processor Version 1.10
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.

Apache Logo