23 template<
typename T,
class A>
26 template<
typename T,
class A>
27 class SLListConstIterator;
29 template<
typename T,
class A>
30 class SLListModifyIterator;
39 template<
typename T,
class A=std::allocator<T> >
61 typedef typename A::template rebind<Element>::other
Allocator;
81 template<
typename T1,
typename A1>
185 inline bool empty()
const;
191 inline int size()
const;
211 Element(
const MemberType& item, Element* next_=0);
222 void deleteNext(Element* current);
237 template<
bool watchForTail>
238 void deleteNext(Element* current);
244 void insertAfter(Element* current,
const T& item);
266 template<
typename T,
class A>
276 : current_(item), list_(sllist)
280 : current_(0), list_(0)
284 : current_(other.iterator_.current_), list_(other.iterator_.list_)
293 return current_->item_;
303 return current_==other.current_;
313 return current_==other.current_;
323 return current_==other.iterator_.current_;
331 current_ = current_->next_;
342 list_->insertAfter(current_, v);
353 list_->deleteNext(current_);
366 template<
class T,
class A>
382 : current_(other.current_)
386 : current_(other.current_)
390 : current_(other.iterator_.current_)
399 return current_->item_;
409 return current_==other.current_;
417 current_ = current_->next_;
428 template<
typename T,
class A>
436 : beforeIterator_(beforeIterator), iterator_(_iterator)
440 : beforeIterator_(other.beforeIterator_), iterator_(other.iterator_)
444 : beforeIterator_(), iterator_()
463 return iterator_== other;
474 return iterator_== other;
485 return iterator_== other.iterator_;
512 beforeIterator_.insertAfter(v);
526 beforeIterator_.deleteNext();
540 template<
typename T,
typename A>
541 ostream& operator<<(ostream& os, const Dune::SLList<T,A> sllist)
544 Iterator end = sllist.end();
545 Iterator current= sllist.begin();
550 os<<*current<<
" ("<<
static_cast<const void*
>(&(*current))<<
")";
553 for(; current != end; ++current)
554 os<<
", "<<*current<<
" ("<<static_cast<const void*>(&(*current))<<
")";
564 template<
typename T,
class A>
566 : next_(next), item_(item)
569 template<
typename T,
class A>
574 template<
typename T,
class A>
580 template<
typename T,
class A>
582 : beforeHead_(), tail_(&beforeHead_), allocator_(), size_(0)
585 assert(&beforeHead_==tail_);
586 assert(tail_->next_==0);
589 template<
typename T,
class A>
591 : beforeHead_(), tail_(&beforeHead_), allocator_(), size_(0)
596 template<
typename T,
class A>
597 template<
typename T1,
class A1>
599 : beforeHead_(), tail_(&beforeHead_), allocator_(), size_(0)
604 template<
typename T,
typename A>
607 assert(tail_==&beforeHead_);
610 Iterator iend = other.
end();
611 for(Iterator element=other.
begin(); element != iend; ++element)
614 assert(other.
size()==size());
617 template<
typename T,
class A>
623 template<
typename T,
class A>
626 if(size()!=other.
size())
629 iter != end(); ++iter, ++oiter)
635 template<
typename T,
class A>
638 if(size()==other.
size()){
640 iter != end(); ++iter, ++oiter)
647 template<
typename T,
class A>
655 template<
typename T,
class A>
658 assert(size_>0 || tail_==&beforeHead_);
659 tail_->next_ = allocator_.allocate(1, 0);
660 assert(size_>0 || tail_==&beforeHead_);
661 tail_ = tail_->next_;
662 ::new (static_cast<void*>(&(tail_->item_))) T(item);
664 assert(tail_->next_==0);
668 template<
typename T,
class A>
674 bool changeTail = (current == tail_);
680 assert(!changeTail || !tmp);
683 current->next_ = allocator_.allocate(1, 0);
686 allocator_.construct(current->next_,
Element(item,tmp));
690 if(!current->next_->next_){
693 tail_ = current->next_;
696 assert(!tail_->next_);
699 template<
typename T,
class A>
702 if(tail_ == &beforeHead_){
704 beforeHead_.next_ = tail_ = allocator_.allocate(1, 0);
705 ::new(static_cast<void*>(&beforeHead_.next_->item_)) T(item);
706 beforeHead_.next_->next_=0;
708 Element* added = allocator_.allocate(1, 0);
709 ::new(static_cast<void*>(&added->item_)) T(item);
710 added->next_=beforeHead_.next_;
711 beforeHead_.next_=added;
713 assert(tail_->next_==0);
718 template<
typename T,
class A>
721 this->
template deleteNext<true>(current);
724 template<
typename T,
class A>
725 template<
bool watchForTail>
726 inline void SLList<T,A>::deleteNext(Element* current)
728 assert(current->next_);
729 Element* next = current->next_;
737 current->next_ = next->next_;
738 allocator_.destroy(next);
739 allocator_.deallocate(next, 1);
741 assert(!watchForTail || &beforeHead_ != tail_ || size_==0);
744 template<
typename T,
class A>
747 deleteNext(&beforeHead_);
750 template<
typename T,
class A>
753 while(beforeHead_.next_ ){
754 this->
template deleteNext<false>(&beforeHead_);
759 tail_ = &beforeHead_;
762 template<
typename T,
class A>
765 return (&beforeHead_ == tail_);
768 template<
typename T,
class A>
774 template<
typename T,
class A>
777 return iterator(beforeHead_.next_,
this);
780 template<
typename T,
class A>
786 template<
typename T,
class A>
792 template<
typename T,
class A>
799 template<
typename T,
class A>
806 template<
typename T,
class A>