Xalan-C++ API Reference  1.12.0
XalanQNameByValueAllocator.hpp
Go to the documentation of this file.
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #if !defined(XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133)
20 #define XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133
21 
22 
23 
24 // Base include file. Must be first.
26 
27 
28 
30 
31 
32 
34 
35 
36 
37 namespace XALAN_CPP_NAMESPACE {
38 
39 
40 
42 {
43 public:
44 
47 
48 #if defined(XALAN_NO_DEFAULT_TEMPLATE_ARGUMENTS)
49  typedef ArenaBlock<data_type> ArenaBlockType;
50  typedef ArenaAllocator<data_type,
51  ArenaBlockType> ArenaAllocatorType;
52 #else
54 #endif
55 
57 
58  /**
59  * Construct an instance that will allocate blocks of the specified size.
60  *
61  * @param theBlockSize The block size.
62  */
64  MemoryManager& theManager,
65  size_type theBlockCount);
66 
68 
69  /**
70  * Create an instance.
71  *
72  * @param theSource The source of the copy.
73  *
74  * @return A pointer to the new instance.
75  */
76  data_type*
77  create(const XalanQNameByValue& theSource);
78 
79  /**
80  * Create an instance.
81  *
82  * @param theNamespace namespace string
83  * @param theLocalPart local part string
84  *
85  * @return A pointer to the new instance.
86  */
87  data_type*
88  create(
89  const XalanDOMString& theNamespaceURI,
90  const XalanDOMString& theLocalPart);
91 
92  /**
93  * Create an instance.
94  *
95  * @param qname QName string
96  * @param namespaces namespace vector stack to use
97  * @param locator The Locator instance for error reporting, if any
98  * @param fUseDefault If true, then elements with no prefix will have the default namespace URI, if there is one.
99  *
100  * @return A pointer to the new instance.
101  */
102  data_type*
103  create(
104  const XalanDOMString& qname,
105  const NamespacesStackType& namespaces,
106  const Locator* locator = 0,
107  bool fUseDefault = false);
108 
109  /**
110  * Create an instance.
111  *
112  * @param qname QName string
113  * @param namespaces namespace vector stack to use
114  * @param locator The Locator instance for error reporting, if any
115  * @param fUseDefault If true, then elements with no prefix will have the default namespace URI, if there is one.
116  *
117  * @return A pointer to the new instance.
118  */
119  data_type*
120  create(
121  const XalanDOMChar* qname,
122  const NamespacesStackType& namespaces,
123  const Locator* locator = 0,
124  bool fUseDefault = false);
125 
126  /**
127  * Create an instance.
128  *
129  * @param qname QName string
130  * @param theResolver prefix resolver to use
131  * @param locator The Locator instance for error reporting, if any
132  *
133  * @return A pointer to the new instance.
134  */
135  data_type*
136  create(
137  const XalanDOMString& qname,
138  const PrefixResolver* theResolver = 0,
139  const Locator* locator = 0);
140 
141  /**
142  * Determine if an object is owned by the allocator...
143  */
144  bool
145  ownsObject(const data_type* theObject)
146  {
147  return m_allocator.ownsObject(theObject);
148  }
149 
150  /**
151  * Delete all objects from the allocator.
152  */
153  void
155  {
156  m_allocator.reset();
157  }
158 
159  /**
160  * Get the number of ArenaBlocks currently allocated.
161  *
162  * @return The number of blocks.
163  */
164  size_type
166  {
167  return m_allocator.getBlockCount();
168  }
169 
170  /**
171  * Get size of an ArenaBlock, that is, the number
172  * of objects in each block.
173  *
174  * @return The size of the block
175  */
176  size_type
177  getBlockSize() const
178  {
179  return m_allocator.getBlockSize();
180  }
181 
182 private:
183 
184  // Not implemented...
186 
188  operator=(const XalanQNameByValueAllocator&);
189 
190  // Data members...
191  ArenaAllocatorType m_allocator;
192 };
193 
194 
195 
196 }
197 
198 
199 
200 #endif // XALANQNAMEBYVALUEALLOCATOR_INCLUDE_GUARD_12455133
size_type getBlockSize() const
Get size of an ArenaBlock, that is, the number of objects in each block.
This class defines an interface for classes that resolve namespace prefixes to their URIs...
ArenaAllocator< data_type > ArenaAllocatorType
#define XALAN_CPP_NAMESPACE
Xalan-C++ namespace, including major and minor version.
void reset()
Delete all objects from the allocator.
data_type::NamespacesStackType NamespacesStackType
bool ownsObject(const data_type *theObject)
Determine if an object is owned by the allocator...
#define XALAN_XPATH_EXPORT
size_type getBlockCount() const
Get the number of ArenaBlocks currently allocated.
ArenaBlock< data_type >::size_type size_type
Xalan implementation of deque.
Definition: XalanDeque.hpp:200