19 #if !defined(XALANLIST_HEADER_GUARD_1357924680) 20 #define XALANLIST_HEADER_GUARD_1357924680 42 XALAN_CPP_NAMESPACE_BEGIN
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,
189 #if defined(XALAN_HAS_STD_ITERATORS) 192 #elif defined(XALAN_RW_NO_CLASS_PARTIAL_SPEC) 199 value_type> reverse_iterator_;
204 const value_type> const_reverse_iterator_;
222 MemoryManager& theManager) :
223 m_memoryManager(&theManager),
233 iterator pos = begin();
236 destroyNode(pos++.node());
239 Node * freeNode = m_freeListHeadPtr;
240 while (freeNode != 0)
242 Node * nextNode = freeNode->next;
243 deallocate(freeNode);
247 deallocate(m_listHead);
254 assert(m_memoryManager != 0 );
256 return *m_memoryManager;
262 assert(m_memoryManager != 0 );
264 return *m_memoryManager;
270 return iterator(*(getListHead().next));
276 return const_iterator(*(getListHead().next));
282 return iterator(getListHead());
288 return const_iterator(getListHead());
294 return reverse_iterator(end());
297 const_reverse_iterator
300 return const_reverse_iterator(end());
306 return reverse_iterator(begin());
309 const_reverse_iterator
312 return const_reverse_iterator(begin());
331 const_iterator item = begin();
332 while (item != end())
343 return (begin() == end()) != 0;
349 constructNode(data, end());
355 constructNode(data, begin());
371 insert(
const iterator& pos,
const value_type& value)
373 return iterator(constructNode(value,pos));
379 assert(pos != end());
380 freeNode(pos.
node());
393 assert(m_memoryManager == list.m_memoryManager);
397 Node & posNode = pos.
node();
398 Node & toInsertNode = toInsert.node();
400 toInsertNode.prev->next = toInsertNode.next;
401 toInsertNode.next->prev = toInsertNode.prev;
403 toInsertNode.prev = posNode.prev;
404 toInsertNode.next = &posNode;
406 posNode.prev->next = &toInsertNode;
407 posNode.prev = &toInsertNode;
419 iterator toInsertFirst,
420 iterator toInsertLast)
422 assert(m_memoryManager == list.m_memoryManager);
424 if (toInsertFirst != toInsertLast)
426 Node & posNode = pos.
node();
427 Node & toInsertFirstNode = toInsertFirst.node();
428 Node & toInsertLastNode = *(toInsertLast.
node().prev);
430 toInsertFirstNode.prev->next = toInsertLastNode.next;
431 toInsertLastNode.next->prev = toInsertFirstNode.prev;
433 toInsertFirstNode.prev = posNode.prev;
434 toInsertLastNode.next = &posNode;
436 posNode.prev->next = &toInsertFirstNode;
437 posNode.prev = &toInsertLastNode;
444 iterator pos = begin();
447 freeNode(pos++.node());
453 #if defined(XALAN_NO_STD_NAMESPACE) 470 Node * nextFreeNode = 0;
472 if (m_freeListHeadPtr != 0)
474 newNode = m_freeListHeadPtr;
475 nextFreeNode = m_freeListHeadPtr->next;
479 m_freeListHeadPtr = allocate(1);
480 newNode = m_freeListHeadPtr;
483 Constructor::construct(&newNode->value, data, *m_memoryManager);
484 new (&newNode->prev) Node*(pos.
node().prev);
485 new (&newNode->next) Node*(&(pos.
node()));
487 pos.
node().prev->next = newNode;
488 pos.
node().prev = newNode;
490 m_freeListHeadPtr = nextFreeNode;
497 node.prev->next = node.next;
498 node.next->prev = node.prev;
502 node.next = m_freeListHeadPtr;
503 m_freeListHeadPtr = &node;
508 assert(&node != m_listHead);
517 m_listHead = allocate(1);
518 m_listHead->next = m_listHead;
519 m_listHead->prev = m_listHead;
527 return const_cast<XalanList*
>(
this)->getListHead();
533 const size_type theBytesNeeded = size *
sizeof(Node);
535 assert(m_memoryManager != 0);
537 void* pointer = m_memoryManager->allocate(theBytesNeeded);
539 assert( pointer != 0 );
548 assert(m_memoryManager != 0);
550 m_memoryManager->deallocate(pointer);
570 XALAN_CPP_NAMESPACE_END
572 #endif // XALANLIST_HEADER_GUARD_1357924680 const_reverse_iterator_ const_reverse_iterator
Node & constructNode(const value_type &data, iterator pos)
void push_front(const value_type &data)
void erase(XalanDOMString &theString)
Remove all elements from target string.
const MemoryManager & getMemoryManager() const
XalanListIteratorBase(Node &node)
XalanListIteratorBase< XalanListConstIteratorTraits< value_type >, Node > const_iterator
XALAN_STD_QUALIFIER bidirectional_iterator_tag iterator_category
XalanListIteratorBase< XalanListIteratorTraits< value_type >, Node > iterator
XalanListIteratorBase operator-(difference_type decrement) const
reverse_iterator_ reverse_iterator
const_reverse_iterator rend() const
reference operator*() const
Node & getListHead() const
bool operator!=(const XalanListIteratorBase &theRhs) const
XalanListIteratorBase(const iterator &theRhs)
XALAN_STD_QUALIFIER reverse_iterator< iterator, value_type > reverse_iterator_
Node * allocate(size_type size)
XalanListIteratorBase< XalanListIteratorTraits< value_type >, Node > iterator
void splice(iterator pos, ThisType &list, iterator toInsert)
XalanListTraits::pointer pointer
void destroyNode(Node &node)
Xalan implementation of a doubly linked list.
XALAN_STD_QUALIFIER reverse_iterator< const_iterator, value_type, const_reference > const_reverse_iterator_
void swap(XalanVector< Type > &theLHS, XalanVector< Type > &theRHS)
XalanListTraits::value_type value_type
ptrdiff_t difference_type
bool operator==(const XalanListIteratorBase &theRhs) const
XalanListIteratorBase operator++()
XalanList< value_type > ThisType
const_iterator begin() const
void push_back(const value_type &data)
void splice(iterator pos, ThisType &list, iterator toInsertFirst, iterator toInsertLast)
XalanListIteratorBase operator--()
const_reverse_iterator rbegin() const
void swap(ThisType &theRHS)
XalanList(MemoryManager &theManager)
XalanListIteratorBase operator++(int)
MemoryManager & getMemoryManager()
pointer operator->() const
const_iterator end() const
bool operator==(const ElemAttributeSet &theLHS, const ElemAttributeSet &theRHS)
MemoryManagedConstructionTraits< value_type >::Constructor Constructor
MemoryManager * m_memoryManager
XalanListTraits::reference reference
const XalanListIteratorBase & operator=(const XalanListIteratorBase &theRhs)
void deallocate(Node *pointer)
reverse_iterator rbegin()
iterator insert(const iterator &pos, const value_type &value)
void freeNode(Node &node)
const value_type * const_pointer
const value_type & const_reference
Node(const value_type &theValue, Node &prevNode, Node &nextNode)