make ParagraphList::push_back take a reference instead of a pointer.

[features.git] / src / ParagraphList.C

diff --git a/src/ParagraphList.C b/src/ParagraphList.C
index 65f1e0ebcec71d1ff9fc2631b4414f378b53d60c..9ebcdebe61d6f0a23c2aad26070fad9972edf260 100644 (file)
--- a/src/ParagraphList.C
+++ b/src/ParagraphList.C
@@ -4,6 +4,8 @@
 
 #include "paragraph.h"
 
+#ifdef NO_STD_LIST
+
 ////////// The ParagraphList::iterator
 
 ParagraphList::iterator::iterator()
@@ -33,11 +35,7 @@ ParagraphList::iterator::operator->()
 ParagraphList::iterator &
 ParagraphList::iterator::operator++()
 {
-#ifndef NO_NEXT
-       ptr = ptr->next_;
-#else
        ptr = ptr->next_par_;
-#endif
        return *this;
 }
 
@@ -54,11 +52,7 @@ ParagraphList::iterator::operator++(int)
 ParagraphList::iterator &
 ParagraphList::iterator::operator--()
 {
-#ifndef NO_NEXT
-       ptr = ptr->previous_;
-#else
        ptr = ptr->prev_par_;
-#endif
        return *this;
 }
 
@@ -86,41 +80,44 @@ bool operator!=(ParagraphList::iterator const & i1,
        return !(i1 == i2);
 }
 
-
+//////////
 ////////// The ParagraphList proper
+//////////
+
 ParagraphList::ParagraphList()
        : parlist(0)
 {}
 
 
+ParagraphList::ParagraphList(ParagraphList const & pl)
+       : parlist(0)
+{
+       // Deep copy.
+       ParagraphList::iterator it = pl.begin();
+       ParagraphList::iterator end = pl.end();
+       for (; it != end; ++it) {
+               push_back(*it);
+       }
+}
+
+
+ParagraphList & ParagraphList::operator=(ParagraphList const & rhs)
+{
+       ParagraphList tmp(rhs);
+       std::swap(parlist, tmp.parlist);
+       return *this;
+}
+
+
 ParagraphList::iterator
 ParagraphList::insert(ParagraphList::iterator it, Paragraph * par)
 {
-#ifndef NO_NEXT
-       if (it != end()) {
-               Paragraph * prev = it->previous_;
-               par->next_ = &*it;
-               par->previous_ = prev;
-               prev->next_ = par;
-               it->previous_ = par;
-       } else if (parlist == 0) {
-               parlist = par;
-       } else {
-               // Find last par.
-               Paragraph * last = parlist;
-               while (last->next_)
-                       last = last->next_;
-               last->next_ = par;
-               par->previous_ = last;
-       }
-       return iterator(par);
-#else
        if (it != end()) {
                Paragraph * prev = it->prev_par_;
                par->next_par_ = &*it;
                par->prev_par_ = prev;
                prev->next_par_ = par;
-               it->prev_ par_= par;
+               it->prev_par_= par;
        } else if (parlist == 0) {
                parlist = par;
        } else {
@@ -132,44 +129,74 @@ ParagraphList::insert(ParagraphList::iterator it, Paragraph * par)
                par->prev_par_ = last;
        }
        return iterator(par);
-#endif
 }
 
 
-void ParagraphList::clear()
+
+void ParagraphList::insert(iterator pos, iterator beg, iterator end)
 {
-#ifndef NO_NEXT
-       while (parlist) {
-               Paragraph * tmp = parlist->next_;
-               delete parlist;
-               parlist = tmp;
+       for (; beg != end; ++beg) {
+               insert(pos, new Paragraph(*beg, false));
+       }
+}
+
+
+void ParagraphList::assign(iterator beg, iterator end)
+{
+       clear();
+       for (; beg != end; ++beg) {
+               push_back(*beg);
        }
-#else
+}
+
+
+void ParagraphList::splice(iterator pos, ParagraphList & pl)
+{
+       if (pl.parlist == 0)
+               return;
+
+       Paragraph * first = pl.parlist;
+       Paragraph * last = first;
+       while (last->next_par_)
+               last = last->next_par_;
+
+       if (pos == end()) {
+               if (parlist == 0) {
+                       parlist = first;
+               } else {
+                       Paragraph * last_par = &back();
+                       last_par->next_par_ = first;
+                       first->prev_par_ = last_par;
+               }
+       } else if (pos == begin()) {
+               last->next_par_ = parlist;
+               parlist->prev_par_ = last;
+               parlist = first;
+       } else {
+               Paragraph * pos_par = &*pos;
+               Paragraph * before_pos = pos_par->prev_par_;
+
+               before_pos->next_par_ = first;
+               first->prev_par_ = before_pos;
+               last->next_par_ = pos_par;
+               pos_par->prev_par_ = last;
+       }
+       pl.parlist = 0;
+}
+
+
+void ParagraphList::clear()
+{
        while (parlist) {
                Paragraph * tmp = parlist->next_par_;
                delete parlist;
                parlist = tmp;
        }
-#endif
 }
 
 
-void ParagraphList::erase(ParagraphList::iterator it)
+ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator it)
 {
-#ifndef NO_NEXT
-       Paragraph * prev = it->previous_;
-       Paragraph * next = it->next_;
-
-       if (prev)
-               prev->next_ = next;
-       else
-               parlist = next;
-
-       if (next)
-               next->previous_ = prev;
-
-       delete &*it;
-#else
        Paragraph * prev = it->prev_par_;
        Paragraph * next = it->next_par_;
 
@@ -182,7 +209,17 @@ void ParagraphList::erase(ParagraphList::iterator it)
                next->prev_par_ = prev;
 
        delete &*it;
-#endif
+       return next;
+}
+
+
+ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator first,
+                             ParagraphList::iterator last)
+{
+       while (first != last) {
+               erase(first++);
+       }
+       return last;
 }
 
 
@@ -224,56 +261,26 @@ Paragraph & ParagraphList::front()
 
 Paragraph const & ParagraphList::back() const
 {
-#ifndef NO_NEXT
-       Paragraph * tmp = parlist;
-       while (tmp->next_)
-               tmp = tmp->next_;
-       return *tmp;
-#else
        Paragraph * tmp = parlist;
        while (tmp->next_par_)
                tmp = tmp->next_par_;
        return *tmp;
-#endif
 }
 
 
 Paragraph & ParagraphList::back()
 {
-#ifndef NO_NEXT
-       Paragraph * tmp = parlist;
-       while (tmp->next_)
-               tmp = tmp->next_;
-       return *tmp;
-#else
        Paragraph * tmp = parlist;
        while (tmp->next_par_)
                tmp = tmp->next_par_;
        return *tmp;
-#endif
 }
 
 
-void ParagraphList::set(Paragraph * p)
+void ParagraphList::push_back(Paragraph const & pr)
 {
-       parlist = p;
-}
-
+       Paragraph * p = new Paragraph(pr, false);
 
-void ParagraphList::push_back(Paragraph * p)
-{
-#ifndef NO_NEXT
-       if (!parlist) {
-               parlist = p;
-               return;
-       }
-
-       Paragraph * pos = parlist;
-       while (pos->next_)
-               pos = pos->next_;
-       pos->next_ = p;
-       p->previous_ = pos;
-#else
        if (!parlist) {
                parlist = p;
                return;
@@ -284,23 +291,11 @@ void ParagraphList::push_back(Paragraph * p)
                pos = pos->next_par_;
        pos->next_par_ = p;
        p->prev_par_ = pos;
-#endif
 }
 
 
 int ParagraphList::size() const
 {
-#ifndef NO_NEXT
-       // When we switch to a std::container this will be O(1)
-       // instead of O(n). (Lgb)
-       Paragraph * tmp = parlist;
-       int c = 0;
-       while (tmp) {
-               ++c;
-               tmp = tmp->next_;
-       }
-       return c;
-#else
        // When we switch to a std::container this will be O(1)
        // instead of O(n). (Lgb)
        Paragraph * tmp = parlist;
@@ -310,7 +305,6 @@ int ParagraphList::size() const
                tmp = tmp->next_par_;
        }
        return c;
-#endif
 }
 
 
@@ -318,3 +312,5 @@ bool ParagraphList::empty() const
 {
        return parlist == 0;
 }
+
+#endif