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

# XalanQNameByValueAllocator.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
    00017 #if !defined(XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133)
    00018 #define XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133
    00019
    00020
    00021
    00022 // Base include file.  Must be first.
    00023 #include <xalanc/XPath/XPathDefinitions.hpp>
    00024
    00025
    00026
    00027 #include <xalanc/XPath/XalanQNameByValue.hpp>
    00028
    00029
    00030
    00031 #include <xalanc/PlatformSupport/ArenaAllocator.hpp>
    00032
    00033
    00034
    00035 XALAN_CPP_NAMESPACE_BEGIN
    00036
    00037
    00038
    00039 class XALAN_XPATH_EXPORT XalanQNameByValueAllocator
    00040 {
    00041 public:
    00042
    00043     typedef XalanQNameByValue                   data_type;
    00044     typedef data_type::NamespacesStackType      NamespacesStackType;
    00045     typedef data_type::LocatorType              LocatorType;
    00046
    00047 #if defined(XALAN_NO_DEFAULT_TEMPLATE_ARGUMENTS)
    00048     typedef ArenaBlock<data_type>               ArenaBlockType;
    00049     typedef ArenaAllocator<data_type,
    00050                            ArenaBlockType>      ArenaAllocatorType;
    00051 #else
    00052     typedef ArenaAllocator<data_type>           ArenaAllocatorType;
    00053 #endif
    00054
    00055     typedef ArenaAllocatorType::size_type       size_type;
    00056
    00062     XalanQNameByValueAllocator(MemoryManagerType&      theManager, size_type        theBlockCount);
    00063
    00064     ~XalanQNameByValueAllocator();
    00065
    00073     data_type*
    00074     create(const XalanQNameByValue& theSource);
    00075
    00084     data_type*
    00085     create(
    00086             const XalanDOMString&   theNamespaceURI,
    00087             const XalanDOMString&   theLocalPart);
    00088
    00099     data_type*
    00100     create(
    00101             const XalanDOMString&       qname,
    00102             const NamespacesStackType&  namespaces,
    00103             const LocatorType*          locator = 0,
    00104             bool                        fUseDefault = false);
    00105
    00116     data_type*
    00117     create(
    00118             const XalanDOMChar*         qname,
    00119             const NamespacesStackType&  namespaces,
    00120             const LocatorType*          locator = 0,
    00121             bool                        fUseDefault = false);
    00122
    00134     data_type*
    00135     create(
    00136             const XalanDOMString&   qname,
    00137             const XalanElement*     namespaceContext,
    00138             const XPathEnvSupport&  envSupport,
    00139             const DOMSupport&       domSupport,
    00140             const LocatorType*      locator = 0);
    00141
    00151     data_type*
    00152     create(
    00153             const XalanDOMString&   qname,
    00154             const PrefixResolver*   theResolver = 0,
    00155             const LocatorType*      locator = 0);
    00156
    00160     bool
    00161     ownsObject(const data_type*     theObject)
    00162     {
    00163         return m_allocator.ownsObject(theObject);
    00164     }
    00165
    00169     void
    00170     reset()
    00171     {
    00172         m_allocator.reset();
    00173     }
    00174
    00180     size_type
    00181     getBlockCount() const
    00182     {
    00183         return m_allocator.getBlockCount();
    00184     }
    00185
    00192     size_type
    00193     getBlockSize() const
    00194     {
    00195         return m_allocator.getBlockSize();
    00196     }
    00197
    00198 private:
    00199
    00200     // Not implemented...
    00201     XalanQNameByValueAllocator(const XalanQNameByValueAllocator&);
    00202
    00203     XalanQNameByValueAllocator&
    00204     operator=(const XalanQNameByValueAllocator&);
    00205
    00206     // Data members...
    00207     ArenaAllocatorType  m_allocator;
    00208 };
    00209
    00210
    00211
    00212 XALAN_CPP_NAMESPACE_END
    00213
    00214
    00215
    00216 #endif  // XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133

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.