19 #if !defined(XALANLIST_HEADER_GUARD_1357924680)
20 #define XALANLIST_HEADER_GUARD_1357924680
46 template <
class Value>
54 template <
class Value>
62 template<
class XalanListTraits,
class Node>
66 typedef typename XalanListTraits::reference
reference;
67 typedef typename XalanListTraits::pointer
pointer;
81 currentNode(theRhs.currentNode)
87 currentNode = currentNode->next;
93 Node& origNode = *currentNode;
94 currentNode = currentNode->next;
100 currentNode = currentNode->prev;
106 Node* node = currentNode;
107 while (decrement > 0)
117 return currentNode->value;
122 return ¤tNode->value;
154 template <
class Type>
172 const value_type & theValue,
198 MemoryManager& theManager) :
199 m_memoryManager(&theManager),
209 iterator pos = begin();
212 destroyNode(pos++.node());
215 Node * freeNode = m_freeListHeadPtr;
216 while (freeNode != 0)
218 Node * nextNode = freeNode->next;
219 deallocate(freeNode);
223 deallocate(m_listHead);
230 assert(m_memoryManager != 0 );
232 return *m_memoryManager;
238 assert(m_memoryManager != 0 );
240 return *m_memoryManager;
246 return iterator(*(getListHead().next));
252 return const_iterator(*(getListHead().next));
258 return iterator(getListHead());
264 return const_iterator(getListHead());
270 return reverse_iterator(end());
273 const_reverse_iterator
276 return const_reverse_iterator(end());
282 return reverse_iterator(begin());
285 const_reverse_iterator
288 return const_reverse_iterator(begin());
307 const_iterator item = begin();
308 while (item != end())
319 return (begin() == end()) != 0;
325 constructNode(data, end());
331 constructNode(data, begin());
347 insert(
const iterator& pos,
const value_type& value)
349 return iterator(constructNode(value,pos));
355 assert(pos != end());
356 freeNode(pos.
node());
369 assert(m_memoryManager == list.m_memoryManager);
373 Node & posNode = pos.
node();
374 Node & toInsertNode = toInsert.node();
376 toInsertNode.prev->next = toInsertNode.next;
377 toInsertNode.next->prev = toInsertNode.prev;
379 toInsertNode.prev = posNode.prev;
380 toInsertNode.next = &posNode;
382 posNode.prev->next = &toInsertNode;
383 posNode.prev = &toInsertNode;
395 iterator toInsertFirst,
396 iterator toInsertLast)
398 assert(m_memoryManager == list.m_memoryManager);
400 if (toInsertFirst != toInsertLast)
402 Node & posNode = pos.
node();
403 Node & toInsertFirstNode = toInsertFirst.node();
404 Node & toInsertLastNode = *(toInsertLast.
node().prev);
406 toInsertFirstNode.prev->next = toInsertLastNode.next;
407 toInsertLastNode.next->prev = toInsertFirstNode.prev;
409 toInsertFirstNode.prev = posNode.prev;
410 toInsertLastNode.next = &posNode;
412 posNode.prev->next = &toInsertFirstNode;
413 posNode.prev = &toInsertLastNode;
420 iterator pos = begin();
423 freeNode(pos++.node());
440 Node * nextFreeNode = 0;
442 if (m_freeListHeadPtr != 0)
444 newNode = m_freeListHeadPtr;
445 nextFreeNode = m_freeListHeadPtr->next;
449 m_freeListHeadPtr = allocate(1);
450 newNode = m_freeListHeadPtr;
453 Constructor::construct(&newNode->value, data, *m_memoryManager);
454 new (&newNode->prev) Node*(pos.
node().prev);
455 new (&newNode->next) Node*(&(pos.
node()));
457 pos.
node().prev->next = newNode;
458 pos.
node().prev = newNode;
460 m_freeListHeadPtr = nextFreeNode;
467 node.prev->next = node.next;
468 node.next->prev = node.prev;
472 node.next = m_freeListHeadPtr;
473 m_freeListHeadPtr = &node;
478 assert(&node != m_listHead);
487 m_listHead = allocate(1);
488 m_listHead->next = m_listHead;
489 m_listHead->prev = m_listHead;
497 return const_cast<XalanList*
>(
this)->getListHead();
503 const size_type theBytesNeeded = size *
sizeof(Node);
505 assert(m_memoryManager != 0);
507 void* pointer = m_memoryManager->allocate(theBytesNeeded);
509 assert( pointer != 0 );
511 return (Node*) pointer;
518 assert(m_memoryManager != 0);
520 m_memoryManager->deallocate(pointer);
542 #endif // XALANLIST_HEADER_GUARD_1357924680
const_reverse_iterator rend() const
XalanListIteratorBase operator-(difference_type decrement) const
XalanListIteratorBase operator++(int)
Xalan implementation of a doubly linked list.
void splice(iterator pos, ThisType &list, iterator toInsertFirst, iterator toInsertLast)
iterator insert(const iterator &pos, const value_type &value)
XalanListTraits::value_type value_type
std::reverse_iterator< iterator > reverse_iterator_
bool operator==(const XalanVector< Type > &theLHS, const XalanVector< Type > &theRHS)
reverse_iterator_ reverse_iterator
ptrdiff_t difference_type
const_reverse_iterator rbegin() const
Node & constructNode(const value_type &data, iterator pos)
XalanList< value_type > ThisType
std::reverse_iterator< const_iterator > const_reverse_iterator_
const XalanListIteratorBase & operator=(const XalanListIteratorBase &theRhs)
const_reverse_iterator_ const_reverse_iterator
reference operator*() const
void erase(XalanDOMString &theString)
Remove all elements from target string.
XalanListIteratorBase< XalanListIteratorTraits< value_type >, Node > iterator
void splice(iterator pos, ThisType &list, iterator toInsert)
XalanListIteratorBase(Node &node)
const MemoryManager & getMemoryManager() const
const_iterator end() const
void freeNode(Node &node)
#define XALAN_CPP_NAMESPACE
Xalan-C++ namespace, including major and minor version.
XalanListIteratorBase< XalanListIteratorTraits< value_type >, Node > iterator
Node * allocate(size_type size)
const_iterator begin() const
pointer operator->() const
MemoryManager * m_memoryManager
void swap(ThisType &theRHS)
std::bidirectional_iterator_tag iterator_category
Node & getListHead() const
void deallocate(Node *pointer)
XalanListTraits::reference reference
bool operator==(const XalanListIteratorBase &theRhs) const
Node(const value_type &theValue, Node &prevNode, Node &nextNode)
void push_front(const value_type &data)
void destroyNode(Node &node)
const value_type * const_pointer
const value_type & const_reference
XalanListIteratorBase operator++()
reverse_iterator rbegin()
void push_back(const value_type &data)
XalanListTraits::pointer pointer
XalanList(MemoryManager &theManager)
XalanListIteratorBase(const iterator &theRhs)
bool operator!=(const XalanListIteratorBase &theRhs) const
XalanListIteratorBase operator--()
MemoryManager & getMemoryManager()
XalanListIteratorBase< XalanListConstIteratorTraits< value_type >, Node > const_iterator
MemoryManagedConstructionTraits< value_type >::Constructor Constructor
void swap(XalanVector< Type > &theLHS, XalanVector< Type > &theRHS)