Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

XalanDeque.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
21 #if !defined(XALANDEQUE_HEADER_GUARD_1357924680)
22 #define XALANDEQUE_HEADER_GUARD_1357924680
23 
24 
25 
26 // Base include file. Must be first.
28 
29 
30 
33 
34 
35 
36 XALAN_CPP_NAMESPACE_BEGIN
37 
38 
39 
40 template <class Value>
42 {
43  typedef Value value_type;
44  typedef Value& reference;
45  typedef Value* pointer;
46  typedef const Value& const_reference;
47 };
48 
49 template <class Value>
51 {
52  typedef Value value_type;
53  typedef const Value& reference;
54  typedef const Value* pointer;
55  typedef const Value& const_reference;
56 };
57 
58 template <class XalanDequeTraits, class XalanDeque>
60 {
61  typedef size_t size_type;
62  typedef typename XalanDequeTraits::value_type value_type;
63  typedef typename XalanDequeTraits::reference reference;
64  typedef typename XalanDequeTraits::pointer pointer;
65  typedef typename XalanDequeTraits::const_reference const_reference;
66  typedef ptrdiff_t difference_type;
67 
69 
70  typedef XALAN_STD_QUALIFIER random_access_iterator_tag iterator_category;
71 
73  size_type pos) :
74  m_deque(deque),
75  m_pos(pos)
76  {
77  }
78 
79  XalanDequeIterator(const Iterator & iterator) :
80  m_deque(iterator.m_deque),
81  m_pos(iterator.m_pos)
82  {
83  }
84 
86  {
87  m_deque = iterator.m_deque;
88  m_pos = iterator.m_pos;
89  return *this;
90  }
91 
93  {
94  ++m_pos;
95  return *this;
96  }
97 
99  {
100  XalanDequeIterator temp = *this;
101  ++m_pos;
102  return temp;
103  }
104 
106  {
107  --m_pos;
108  return *this;
109  }
110 
112  {
113  return &(*m_deque[m_pos]);
114  }
115 
117  {
118  return (*m_deque)[m_pos];
119  }
120 
122  {
123  return (*m_deque)[m_pos];
124  }
125 
127  {
128  return XalanDequeIterator(m_deque, m_pos + difference);
129  }
130 
132  {
133  return XalanDequeIterator(m_deque, m_pos - difference);
134  }
135 
137  {
138  return m_pos - theRhs.m_pos;
139  }
140 
141  bool operator==(const XalanDequeIterator & theRhs) const
142  {
143  return (theRhs.m_deque == m_deque)
144  && theRhs.m_pos == m_pos;
145  }
146 
147  bool operator!=(const XalanDequeIterator & theRhs) const
148  {
149  return !(theRhs == *this);
150  }
151 
154 };
155 
159 template <class Type, class ConstructionTraits = MemoryManagedConstructionTraits<Type> >
161 {
162 public:
163 
164 
165  typedef size_t size_type;
166 
167  typedef Type value_type;
168  typedef Type& reference;
169  typedef const Type& const_reference;
170 
172 
174 
178 
179 #if defined(XALAN_HAS_STD_ITERATORS)
180  typedef XALAN_STD_QUALIFIER reverse_iterator<iterator> reverse_iterator_;
181  typedef XALAN_STD_QUALIFIER reverse_iterator<const_iterator> const_reverse_iterator_;
182 #elif defined(XALAN_RW_NO_CLASS_PARTIAL_SPEC)
183  typedef XALAN_STD_QUALIFIER reverse_iterator<
184  iterator,
185  XALAN_STD_QUALIFIER random_access_iterator_tag,
187  typedef XALAN_STD_QUALIFIER reverse_iterator<
189  XALAN_STD_QUALIFIER random_access_iterator_tag,
191 #else
194 #endif
195 
198 
200  MemoryManagerType& memoryManager,
201  size_type initialSize = 0,
202  size_type blockSize = 10) :
203  m_memoryManager(&memoryManager),
204  m_blockSize(blockSize),
205  m_blockIndex(memoryManager,
206  initialSize / blockSize + (initialSize % blockSize == 0 ? 0 : 1)),
207  m_freeBlockVector(memoryManager)
208  {
209  typename ConstructionTraits::Constructor::ConstructableType defaultValue(*m_memoryManager);
210 
211  XALAN_STD_QUALIFIER fill_n(XALAN_STD_QUALIFIER back_inserter(*this), initialSize, defaultValue.value);
212  }
213 
214  XalanDeque(const XalanDeque& theRhs, MemoryManagerType& memoryManager) :
215  m_memoryManager(&memoryManager),
216  m_blockSize(theRhs.m_blockSize),
218  theRhs.size() / theRhs.m_blockSize + (theRhs.size() % theRhs.m_blockSize == 0 ? 0 : 1)),
219  m_freeBlockVector(memoryManager)
220  {
221  XALAN_STD_QUALIFIER copy(theRhs.begin(), theRhs.end(), XALAN_STD_QUALIFIER back_inserter(*this));
222  }
223 
224  static XalanDeque*
226  MemoryManagerType& theManager,
227  size_type initialSize = 0,
228  size_type blockSize = 10)
229  {
230  typedef XalanDeque ThisType;
231 
232  XalanMemMgrAutoPtr<ThisType, false> theGuard( theManager , (ThisType*)theManager.allocate(sizeof(ThisType)));
233 
234  ThisType* theResult = theGuard.get();
235 
236  new (theResult) ThisType(theManager, initialSize, blockSize);
237 
238  theGuard.release();
239 
240  return theResult;
241  }
242 
244  {
245  clear();
247 
248  while (iter != m_freeBlockVector.end())
249  {
250  (*iter)->~XalanVector<Type, ConstructionTraits>();
251  deallocate(*iter);
252  ++iter;
253  }
254  }
255 
257  {
258  return iterator(this, 0);
259  }
260 
262  {
263  return const_iterator(const_cast<XalanDeque*>(this), 0);
264  }
265 
267  {
268  return iterator(this, size());
269  }
270 
272  {
273  return const_iterator(const_cast<XalanDeque*>(this), size());
274  }
275 
277  {
278  return const_reverse_iterator(end());
279  }
280 
282  {
283  return const_reverse_iterator(begin());
284  }
285 
286  bool empty() const
287  {
288  return m_blockIndex.empty();
289  }
290 
291  size_type size() const
292  {
293  if (m_blockIndex.empty())
294  {
295  return 0;
296  }
297  else
298  {
299  return (m_blockIndex.size() - 1) * m_blockSize
300  + m_blockIndex.back()->size();
301  }
302  }
303 
305  {
306  return m_blockIndex.back()->back();
307  }
308 
310  {
311  BlockType & block = *(m_blockIndex[index / m_blockSize]);
312  return block[index % m_blockSize];
313  }
314 
315  const value_type& operator[](size_type index) const
316  {
317  BlockType & block = *(m_blockIndex[index / m_blockSize]);
318  return block[index % m_blockSize];
319  }
320 
321  void clear()
322  {
323  typename BlockIndexType::iterator iter = m_blockIndex.begin();
324 
326 
327  while (iter != m_blockIndex.end())
328  {
329  (*iter)->clear();
331  ++iter;
332  }
333 
335  }
336 
337  void push_back(const value_type & value)
338  {
339  if (m_blockIndex.empty() ||
340  m_blockIndex.back()->size() >= m_blockSize)
341  {
343  }
344 
345  m_blockIndex.back()->push_back(value);
346  }
347 
348  void pop_back()
349  {
350  BlockType & lastBlock = *(m_blockIndex.back());
351  lastBlock.pop_back();
352  if (lastBlock.empty())
353  {
354  m_freeBlockVector.push_back(&lastBlock);
356  }
357  }
358 
359  void resize(size_type newSize)
360  {
361  typename ConstructionTraits::Constructor::ConstructableType defaultValue(*m_memoryManager);
362  if (newSize > size())
363  {
364  for (size_type i = 0; i < newSize - size(); ++i)
365  {
366  push_back(defaultValue.value);
367  }
368  }
369  else
370  {
371  for (size_type i = 0; i < size() - newSize; ++i)
372  {
373  pop_back();
374  }
375  }
376  }
377 
378  void swap(XalanDeque& theRhs)
379  {
380  MemoryManagerType* tempMemoryManager = m_memoryManager;
382  theRhs.m_memoryManager = tempMemoryManager;
383 
386  }
387 
388  XalanDeque & operator=(const XalanDeque & theRhs)
389  {
390  clear();
391  XALAN_STD_QUALIFIER copy(theRhs.begin(), theRhs.end(), XALAN_STD_QUALIFIER back_inserter(*this));
392  return *this;
393  }
394 
397  {
398  assert (m_memoryManager != 0);
399 
400  return *m_memoryManager;
401  }
402 protected:
403 
405  {
406  BlockType * newBlock;
407 
408  if (m_freeBlockVector.empty())
409  {
410  newBlock = allocate(1);
411  new (&*newBlock) BlockType(*m_memoryManager, m_blockSize);
412  }
413  else
414  {
415  newBlock = m_freeBlockVector.back();
417  }
418 
419  assert (newBlock != 0);
420 
421  return newBlock;
422  }
423 
424  BlockType*
426  {
427  const size_type theBytesNeeded = size * sizeof(BlockType);
428 
429  BlockType* pointer = (BlockType*)m_memoryManager->allocate(theBytesNeeded);
430 
431  assert(pointer != 0);
432 
433  return pointer;
434  }
435 
436  void
438  {
439  m_memoryManager->deallocate(pointer);
440  }
441 
444 
447 
448 private:
449  // Not implemented
450  XalanDeque();
451  XalanDeque(const XalanDeque&);
452 
453 };
454 
455 
456 
457 XALAN_CPP_NAMESPACE_END
458 
459 
460 
461 #endif // XALANDEQUE_HEADER_GUARD_1357924680
462 
Value value_type
Definition: XalanDeque.hpp:52
XalanVector< BlockType * > BlockIndexType
Definition: XalanDeque.hpp:173
const size_type m_blockSize
Definition: XalanDeque.hpp:443
Value & reference
Definition: XalanDeque.hpp:44
Definition: XalanDeque.hpp:41
XalanDequeIterator & operator=(const Iterator &iterator)
Definition: XalanDeque.hpp:85
XALAN_CPP_NAMESPACE_BEGIN typedef XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager MemoryManagerType
Definition: XalanMemoryManagement.hpp:39
iterator end()
Definition: XalanVector.hpp:701
const Value * pointer
Definition: XalanDeque.hpp:54
BlockType * getNewBlock()
Definition: XalanDeque.hpp:404
const_iterator end() const
Definition: XalanDeque.hpp:271
void deallocate(BlockType *pointer)
Definition: XalanDeque.hpp:437
value_type & back()
Definition: XalanDeque.hpp:304
value_type * iterator
Definition: XalanVector.hpp:91
void resize(size_type newSize)
Definition: XalanDeque.hpp:359
XALAN_STD_QUALIFIER reverse_iterator< const_iterator, value_type, const_reference > const_reverse_iterator_
Definition: XalanDeque.hpp:193
bool operator==(const XalanDequeIterator &theRhs) const
Definition: XalanDeque.hpp:141
XalanDequeIterator< XalanDequeConstIteratorTraits< value_type >, ThisType > const_iterator
Definition: XalanDeque.hpp:177
XalanDequeIterator operator+(difference_type difference) const
Definition: XalanDeque.hpp:126
BlockIndexType m_blockIndex
Definition: XalanDeque.hpp:445
XalanDeque(MemoryManagerType &memoryManager, size_type initialSize=0, size_type blockSize=10)
Definition: XalanDeque.hpp:199
reference back()
Definition: XalanVector.hpp:673
MemoryManagerType & getMemoryManager()
Definition: XalanDeque.hpp:396
void push_back(const value_type &value)
Definition: XalanDeque.hpp:337
void pop_back()
Definition: XalanVector.hpp:256
reference operator*()
Definition: XalanDeque.hpp:116
Type & reference
Definition: XalanDeque.hpp:168
XalanVector< Type, ConstructionTraits > BlockType
Definition: XalanDeque.hpp:171
XALAN_STD_QUALIFIER reverse_iterator< iterator, value_type > reverse_iterator_
Definition: XalanDeque.hpp:192
bool empty() const
Definition: XalanVector.hpp:636
Definition: XalanDeque.hpp:50
void push_back(const value_type &data)
Definition: XalanVector.hpp:246
XalanDequeTraits::pointer pointer
Definition: XalanDeque.hpp:64
value_type & operator[](size_type index)
Definition: XalanDeque.hpp:309
Value value_type
Definition: XalanDeque.hpp:43
iterator begin()
Definition: XalanVector.hpp:685
size_type size() const
Definition: XalanDeque.hpp:291
Value * pointer
Definition: XalanDeque.hpp:45
size_t size_type
Definition: XalanDeque.hpp:61
size_t size_type
Definition: XalanDeque.hpp:165
const Value & const_reference
Definition: XalanDeque.hpp:46
const value_type & operator[](size_type index) const
Definition: XalanDeque.hpp:315
reverse_iterator_ reverse_iterator
Definition: XalanDeque.hpp:196
XalanDequeTraits::value_type value_type
Definition: XalanDeque.hpp:62
XalanDeque(const XalanDeque &theRhs, MemoryManagerType &memoryManager)
Definition: XalanDeque.hpp:214
void reserve(size_type theSize)
Definition: XalanVector.hpp:644
XalanDequeIterator operator++(int)
Definition: XalanDeque.hpp:98
const Value & const_reference
Definition: XalanDeque.hpp:55
const Type & const_reference
Definition: XalanDeque.hpp:169
XalanDeque< Type, ConstructionTraits > ThisType
Definition: XalanDeque.hpp:175
difference_type operator-(const XalanDequeIterator &theRhs) const
Definition: XalanDeque.hpp:136
Type * get() const
Definition: XalanMemMgrAutoPtr.hpp:164
const_reverse_iterator_ const_reverse_iterator
Definition: XalanDeque.hpp:197
XalanDeque & operator=(const XalanDeque &theRhs)
Definition: XalanDeque.hpp:388
XalanDequeIterator & operator++()
Definition: XalanDeque.hpp:92
size_type size() const
Definition: XalanVector.hpp:571
BlockIndexType m_freeBlockVector
Definition: XalanDeque.hpp:446
Definition: XalanMemMgrAutoPtr.hpp:46
void clear()
Definition: XalanDeque.hpp:321
bool empty() const
Definition: XalanDeque.hpp:286
BlockType * allocate(size_type size)
Definition: XalanDeque.hpp:425
static XalanDeque * create(MemoryManagerType &theManager, size_type initialSize=0, size_type blockSize=10)
Definition: XalanDeque.hpp:225
const_iterator begin() const
Definition: XalanDeque.hpp:261
XalanDequeIterator< XalanDequeIteratorTraits< value_type >, ThisType > iterator
Definition: XalanDeque.hpp:176
XalanDequeIterator< XalanDequeIteratorTraits< value_type >, XalanDeque > Iterator
Definition: XalanDeque.hpp:68
void swap(ThisType &theOther)
Definition: XalanVector.hpp:848
XalanDequeIterator(const Iterator &iterator)
Definition: XalanDeque.hpp:79
size_type m_pos
Definition: XalanDeque.hpp:153
const_reverse_iterator rbegin() const
Definition: XalanDeque.hpp:276
ptrdiff_t difference_type
Definition: XalanDeque.hpp:66
const_reference operator*() const
Definition: XalanDeque.hpp:121
XalanDeque * m_deque
Definition: XalanDeque.hpp:152
Type value_type
Definition: XalanDeque.hpp:167
const_reverse_iterator rend() const
Definition: XalanDeque.hpp:281
void clear()
Definition: XalanVector.hpp:788
void swap(XalanDeque &theRhs)
Definition: XalanDeque.hpp:378
XALAN_STD_QUALIFIER random_access_iterator_tag iterator_category
Definition: XalanDeque.hpp:70
This class is deprecated.
Definition: XercesBridgeNavigator.hpp:53
pointer operator->()
Definition: XalanDeque.hpp:111
iterator end()
Definition: XalanDeque.hpp:266
const Value & reference
Definition: XalanDeque.hpp:53
void pop_back()
Definition: XalanDeque.hpp:348
bool operator!=(const XalanDequeIterator &theRhs) const
Definition: XalanDeque.hpp:147
Definition: XalanVector.hpp:61
iterator begin()
Definition: XalanDeque.hpp:256
MemoryManagerType * m_memoryManager
Definition: XalanDeque.hpp:442
XalanDequeIterator(XalanDeque *deque, size_type pos)
Definition: XalanDeque.hpp:72
Xalan implementation of deque.
Definition: XalanDeque.hpp:160
~XalanDeque()
Definition: XalanDeque.hpp:243
XalanDequeTraits::const_reference const_reference
Definition: XalanDeque.hpp:65
XalanDequeTraits::reference reference
Definition: XalanDeque.hpp:63
XalanDequeIterator & operator--()
Definition: XalanDeque.hpp:105
XalanDequeIterator operator-(difference_type difference) const
Definition: XalanDeque.hpp:131
Definition: XalanDeque.hpp:59

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