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 131380d6442e9b75a26101667389b369b4c3a4f9..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,7 +35,7 @@ ParagraphList::iterator::operator->()
 ParagraphList::iterator &
 ParagraphList::iterator::operator++()
 {
-       ptr = ptr->next();
+       ptr = ptr->next_par_;
        return *this;
 }
 
@@ -50,7 +52,7 @@ ParagraphList::iterator::operator++(int)
 ParagraphList::iterator &
 ParagraphList::iterator::operator--()
 {
-       ptr = ptr->previous();
+       ptr = ptr->prev_par_;
        return *this;
 }
 
@@ -78,23 +80,149 @@ 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)
+{
+       if (it != end()) {
+               Paragraph * prev = it->prev_par_;
+               par->next_par_ = &*it;
+               par->prev_par_ = prev;
+               prev->next_par_ = par;
+               it->prev_par_= par;
+       } else if (parlist == 0) {
+               parlist = par;
+       } else {
+               // Find last par.
+               Paragraph * last = parlist;
+               while (last->next_par_)
+                       last = last->next_par_;
+               last->next_par_ = par;
+               par->prev_par_ = last;
+       }
+       return iterator(par);
+}
+
+
+
+void ParagraphList::insert(iterator pos, iterator beg, iterator end)
+{
+       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);
+       }
+}
+
+
+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();
+               Paragraph * tmp = parlist->next_par_;
                delete parlist;
                parlist = tmp;
        }
 }
 
 
+ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator it)
+{
+       Paragraph * prev = it->prev_par_;
+       Paragraph * next = it->next_par_;
+
+       if (prev)
+               prev->next_par_ = next;
+       else
+               parlist = next;
+
+       if (next)
+               next->prev_par_ = prev;
+
+       delete &*it;
+       return next;
+}
+
+
+ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator first,
+                             ParagraphList::iterator last)
+{
+       while (first != last) {
+               erase(first++);
+       }
+       return last;
+}
+
+
 ParagraphList::iterator ParagraphList::begin()
 {
        return iterator(parlist);
@@ -119,24 +247,50 @@ ParagraphList::iterator ParagraphList::end() const
 }
 
 
-void ParagraphList::set(Paragraph * p)
+Paragraph const & ParagraphList::front() const
 {
-       parlist = p;
+       return *parlist;
 }
 
 
-void ParagraphList::push_back(Paragraph * p)
+Paragraph & ParagraphList::front()
 {
+       return *parlist;
+}
+
+
+Paragraph const & ParagraphList::back() const
+{
+       Paragraph * tmp = parlist;
+       while (tmp->next_par_)
+               tmp = tmp->next_par_;
+       return *tmp;
+}
+
+
+Paragraph & ParagraphList::back()
+{
+       Paragraph * tmp = parlist;
+       while (tmp->next_par_)
+               tmp = tmp->next_par_;
+       return *tmp;
+}
+
+
+void ParagraphList::push_back(Paragraph const & pr)
+{
+       Paragraph * p = new Paragraph(pr, false);
+
        if (!parlist) {
                parlist = p;
                return;
        }
 
        Paragraph * pos = parlist;
-       while (pos->next())
-               pos = pos->next();
-       pos->next(p);
-       p->previous(pos);
+       while (pos->next_par_)
+               pos = pos->next_par_;
+       pos->next_par_ = p;
+       p->prev_par_ = pos;
 }
 
 
@@ -148,7 +302,7 @@ int ParagraphList::size() const
        int c = 0;
        while (tmp) {
                ++c;
-               tmp = tmp->next();
+               tmp = tmp->next_par_;
        }
        return c;
 }
@@ -158,3 +312,5 @@ bool ParagraphList::empty() const
 {
        return parlist == 0;
 }
+
+#endif