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

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