src/ParagraphList.C

   1 #include <config.h>
   2
   3 #include "ParagraphList.h"
   4
   5 #include "paragraph.h"
   6
   7 #ifdef NO_STD_LIST
   8
   9 ////////// The ParagraphList::iterator
  10
  11 ParagraphList::iterator::iterator()
  12         : ptr(0)
  13 {}
  14
  15
  16 ParagraphList::iterator::iterator(Paragraph * p)
  17         : ptr(p)
  18 {}
  19
  20
  21 ParagraphList::iterator::reference
  22 ParagraphList::iterator::operator*()
  23 {
  24         return *ptr;
  25 }
  26
  27
  28 ParagraphList::iterator::pointer
  29 ParagraphList::iterator::operator->()
  30 {
  31         return ptr;
  32 }
  33
  34
  35 ParagraphList::iterator &
  36 ParagraphList::iterator::operator++()
  37 {
  38         ptr = ptr->next_par_;
  39         return *this;
  40 }
  41
  42
  43 ParagraphList::iterator
  44 ParagraphList::iterator::operator++(int)
  45 {
  46         iterator tmp = *this;
  47         ++*this;
  48         return tmp;
  49 }
  50
  51
  52 ParagraphList::iterator &
  53 ParagraphList::iterator::operator--()
  54 {
  55         ptr = ptr->prev_par_;
  56         return *this;
  57 }
  58
  59
  60 ParagraphList::iterator
  61 ParagraphList::iterator::operator--(int)
  62 {
  63         iterator tmp = *this;
  64         --*this;
  65         return tmp;
  66 }
  67
  68
  69 bool operator==(ParagraphList::iterator const & i1,
  70                 ParagraphList::iterator const & i2)
  71 {
  72         return &(*const_cast<ParagraphList::iterator&>(i1))
  73             == &(*const_cast<ParagraphList::iterator&>(i2));
  74 }
  75
  76
  77 bool operator!=(ParagraphList::iterator const & i1,
  78                 ParagraphList::iterator const & i2)
  79 {
  80         return !(i1 == i2);
  81 }
  82
  83 //////////
  84 ////////// The ParagraphList proper
  85 //////////
  86
  87 ParagraphList::ParagraphList()
  88         : parlist(0)
  89 {}
  90
  91
  92 ParagraphList::ParagraphList(ParagraphList const & pl)
  93         : parlist(0)
  94 {
  95         // Deep copy.
  96         ParagraphList::iterator it = pl.begin();
  97         ParagraphList::iterator end = pl.end();
  98         for (; it != end; ++it) {
  99                 push_back(*it);
 100         }
 101 }
 102
 103
 104 ParagraphList & ParagraphList::operator=(ParagraphList const & rhs)
 105 {
 106         ParagraphList tmp(rhs);
 107         std::swap(parlist, tmp.parlist);
 108         return *this;
 109 }
 110
 111
 112 ParagraphList::iterator
 113 ParagraphList::insert(ParagraphList::iterator it, Paragraph const & p)
 114 {
 115         Paragraph * par = new Paragraph(p, false);
 116
 117         if (it != end()) {
 118                 Paragraph * prev = it->prev_par_;
 119                 par->next_par_ = &*it;
 120                 par->prev_par_ = prev;
 121                 prev->next_par_ = par;
 122                 it->prev_par_= par;
 123         } else if (parlist == 0) {
 124                 parlist = par;
 125         } else {
 126                 // Find last par.
 127                 Paragraph * last = parlist;
 128                 while (last->next_par_)
 129                         last = last->next_par_;
 130                 last->next_par_ = par;
 131                 par->prev_par_ = last;
 132         }
 133         return iterator(par);
 134 }
 135
 136
 137
 138 void ParagraphList::insert(iterator pos, iterator beg, iterator end)
 139 {
 140         for (; beg != end; ++beg) {
 141                 insert(pos, *beg);
 142         }
 143 }
 144
 145
 146 void ParagraphList::assign(iterator beg, iterator end)
 147 {
 148         clear();
 149         for (; beg != end; ++beg) {
 150                 push_back(*beg);
 151         }
 152 }
 153
 154
 155 void ParagraphList::splice(iterator pos, ParagraphList & pl)
 156 {
 157         if (pl.parlist == 0)
 158                 return;
 159
 160         Paragraph * first = pl.parlist;
 161         Paragraph * last = first;
 162         while (last->next_par_)
 163                 last = last->next_par_;
 164
 165         if (pos == end()) {
 166                 if (parlist == 0) {
 167                         parlist = first;
 168                 } else {
 169                         Paragraph * last_par = &back();
 170                         last_par->next_par_ = first;
 171                         first->prev_par_ = last_par;
 172                 }
 173         } else if (pos == begin()) {
 174                 last->next_par_ = parlist;
 175                 parlist->prev_par_ = last;
 176                 parlist = first;
 177         } else {
 178                 Paragraph * pos_par = &*pos;
 179                 Paragraph * before_pos = pos_par->prev_par_;
 180
 181                 before_pos->next_par_ = first;
 182                 first->prev_par_ = before_pos;
 183                 last->next_par_ = pos_par;
 184                 pos_par->prev_par_ = last;
 185         }
 186         pl.parlist = 0;
 187 }
 188
 189
 190 void ParagraphList::clear()
 191 {
 192         while (parlist) {
 193                 Paragraph * tmp = parlist->next_par_;
 194                 delete parlist;
 195                 parlist = tmp;
 196         }
 197 }
 198
 199
 200 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator it)
 201 {
 202         Paragraph * prev = it->prev_par_;
 203         Paragraph * next = it->next_par_;
 204
 205         if (prev)
 206                 prev->next_par_ = next;
 207         else
 208                 parlist = next;
 209
 210         if (next)
 211                 next->prev_par_ = prev;
 212
 213         delete &*it;
 214         return next;
 215 }
 216
 217
 218 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator first,
 219                               ParagraphList::iterator last)
 220 {
 221         while (first != last) {
 222                 erase(first++);
 223         }
 224         return last;
 225 }
 226
 227
 228 ParagraphList::iterator ParagraphList::begin()
 229 {
 230         return iterator(parlist);
 231 }
 232
 233
 234 ParagraphList::iterator ParagraphList::begin() const
 235 {
 236         return iterator(parlist);
 237 }
 238
 239
 240 ParagraphList::iterator ParagraphList::end()
 241 {
 242         return iterator();
 243 }
 244
 245
 246 ParagraphList::iterator ParagraphList::end() const
 247 {
 248         return iterator();
 249 }
 250
 251
 252 Paragraph const & ParagraphList::front() const
 253 {
 254         return *parlist;
 255 }
 256
 257
 258 Paragraph & ParagraphList::front()
 259 {
 260         return *parlist;
 261 }
 262
 263
 264 Paragraph const & ParagraphList::back() const
 265 {
 266         Paragraph * tmp = parlist;
 267         while (tmp->next_par_)
 268                 tmp = tmp->next_par_;
 269         return *tmp;
 270 }
 271
 272
 273 Paragraph & ParagraphList::back()
 274 {
 275         Paragraph * tmp = parlist;
 276         while (tmp->next_par_)
 277                 tmp = tmp->next_par_;
 278         return *tmp;
 279 }
 280
 281
 282 void ParagraphList::push_back(Paragraph const & pr)
 283 {
 284         Paragraph * p = new Paragraph(pr, false);
 285
 286         if (!parlist) {
 287                 parlist = p;
 288                 return;
 289         }
 290
 291         Paragraph * pos = parlist;
 292         while (pos->next_par_)
 293                 pos = pos->next_par_;
 294         pos->next_par_ = p;
 295         p->prev_par_ = pos;
 296 }
 297
 298
 299 int ParagraphList::size() const
 300 {
 301         // When we switch to a std::container this will be O(1)
 302         // instead of O(n). (Lgb)
 303         Paragraph * tmp = parlist;
 304         int c = 0;
 305         while (tmp) {
 306                 ++c;
 307                 tmp = tmp->next_par_;
 308         }
 309         return c;
 310 }
 311
 312
 313 bool ParagraphList::empty() const
 314 {
 315         return parlist == 0;
 316 }
 317
 318 #endif