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 ////////// The ParagraphList::const_iterator
  84
  85 ParagraphList::const_iterator::const_iterator()
  86         : ptr(0)
  87 {}
  88
  89
  90 ParagraphList::const_iterator::const_iterator(Paragraph * p)
  91         : ptr(p)
  92 {}
  93
  94
  95 ParagraphList::const_iterator::const_reference
  96 ParagraphList::const_iterator::operator*()
  97 {
  98         return *ptr;
  99 }
 100
 101
 102 ParagraphList::const_iterator::const_pointer
 103 ParagraphList::const_iterator::operator->()
 104 {
 105         return ptr;
 106 }
 107
 108
 109 ParagraphList::const_iterator &
 110 ParagraphList::const_iterator::operator++()
 111 {
 112         ptr = ptr->next_par_;
 113         return *this;
 114 }
 115
 116
 117 ParagraphList::const_iterator
 118 ParagraphList::const_iterator::operator++(int)
 119 {
 120         const_iterator tmp = *this;
 121         ++*this;
 122         return tmp;
 123 }
 124
 125
 126 ParagraphList::const_iterator &
 127 ParagraphList::const_iterator::operator--()
 128 {
 129         ptr = ptr->prev_par_;
 130         return *this;
 131 }
 132
 133
 134 ParagraphList::const_iterator
 135 ParagraphList::const_iterator::operator--(int)
 136 {
 137         const_iterator tmp = *this;
 138         --*this;
 139         return tmp;
 140 }
 141
 142
 143 bool operator==(ParagraphList::const_iterator const & i1,
 144                 ParagraphList::const_iterator const & i2)
 145 {
 146         return &(*const_cast<ParagraphList::const_iterator&>(i1))
 147             == &(*const_cast<ParagraphList::const_iterator&>(i2));
 148 }
 149
 150
 151 bool operator!=(ParagraphList::const_iterator const & i1,
 152                 ParagraphList::const_iterator const & i2)
 153 {
 154         return !(i1 == i2);
 155 }
 156
 157 //////////
 158 ////////// The ParagraphList proper
 159 //////////
 160
 161 ParagraphList::ParagraphList()
 162         : parlist(0)
 163 {}
 164
 165
 166 ParagraphList::ParagraphList(ParagraphList const & pl)
 167         : parlist(0)
 168 {
 169         // Deep copy.
 170         ParagraphList::const_iterator it = pl.begin();
 171         ParagraphList::const_iterator end = pl.end();
 172         for (; it != end; ++it) {
 173                 push_back(*it);
 174         }
 175 }
 176
 177
 178 ParagraphList & ParagraphList::operator=(ParagraphList const & rhs)
 179 {
 180         ParagraphList tmp(rhs);
 181         std::swap(parlist, tmp.parlist);
 182         return *this;
 183 }
 184
 185
 186 ParagraphList::iterator
 187 ParagraphList::insert(ParagraphList::iterator it, Paragraph const & p)
 188 {
 189         Paragraph * par = new Paragraph(p);
 190
 191         if (it != end()) {
 192                 Paragraph * prev = it->prev_par_;
 193                 par->next_par_ = &*it;
 194                 par->prev_par_ = prev;
 195                 prev->next_par_ = par;
 196                 it->prev_par_= par;
 197         } else if (parlist == 0) {
 198                 parlist = par;
 199         } else {
 200                 // Find last par.
 201                 Paragraph * last = parlist;
 202                 while (last->next_par_)
 203                         last = last->next_par_;
 204                 last->next_par_ = par;
 205                 par->prev_par_ = last;
 206         }
 207         return iterator(par);
 208 }
 209
 210
 211
 212 void ParagraphList::insert(iterator pos, iterator beg, iterator end)
 213 {
 214         for (; beg != end; ++beg) {
 215                 insert(pos, *beg);
 216         }
 217 }
 218
 219
 220 void ParagraphList::assign(iterator beg, iterator end)
 221 {
 222         clear();
 223         for (; beg != end; ++beg) {
 224                 push_back(*beg);
 225         }
 226 }
 227
 228
 229 void ParagraphList::splice(iterator pos, ParagraphList & pl)
 230 {
 231         if (pl.parlist == 0)
 232                 return;
 233
 234         Paragraph * first = pl.parlist;
 235         Paragraph * last = first;
 236         while (last->next_par_)
 237                 last = last->next_par_;
 238
 239         if (pos == end()) {
 240                 if (parlist == 0) {
 241                         parlist = first;
 242                 } else {
 243                         Paragraph * last_par = &back();
 244                         last_par->next_par_ = first;
 245                         first->prev_par_ = last_par;
 246                 }
 247         } else if (pos == begin()) {
 248                 last->next_par_ = parlist;
 249                 parlist->prev_par_ = last;
 250                 parlist = first;
 251         } else {
 252                 Paragraph * pos_par = &*pos;
 253                 Paragraph * before_pos = pos_par->prev_par_;
 254
 255                 before_pos->next_par_ = first;
 256                 first->prev_par_ = before_pos;
 257                 last->next_par_ = pos_par;
 258                 pos_par->prev_par_ = last;
 259         }
 260         pl.parlist = 0;
 261 }
 262
 263
 264 void ParagraphList::clear()
 265 {
 266         while (parlist) {
 267                 Paragraph * tmp = parlist->next_par_;
 268                 delete parlist;
 269                 parlist = tmp;
 270         }
 271 }
 272
 273
 274 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator it)
 275 {
 276         Paragraph * prev = it->prev_par_;
 277         Paragraph * next = it->next_par_;
 278
 279         if (prev)
 280                 prev->next_par_ = next;
 281         else
 282                 parlist = next;
 283
 284         if (next)
 285                 next->prev_par_ = prev;
 286
 287         delete &*it;
 288         return next;
 289 }
 290
 291
 292 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator first,
 293                               ParagraphList::iterator last)
 294 {
 295         while (first != last) {
 296                 erase(first++);
 297         }
 298         return last;
 299 }
 300
 301
 302 ParagraphList::iterator ParagraphList::begin()
 303 {
 304         return iterator(parlist);
 305 }
 306
 307
 308 ParagraphList::const_iterator ParagraphList::begin() const
 309 {
 310         return const_iterator(parlist);
 311 }
 312
 313
 314 ParagraphList::iterator ParagraphList::end()
 315 {
 316         return iterator();
 317 }
 318
 319
 320 ParagraphList::const_iterator ParagraphList::end() const
 321 {
 322         return const_iterator();
 323 }
 324
 325
 326 Paragraph const & ParagraphList::front() const
 327 {
 328         return *parlist;
 329 }
 330
 331
 332 Paragraph & ParagraphList::front()
 333 {
 334         return *parlist;
 335 }
 336
 337
 338 Paragraph const & ParagraphList::back() const
 339 {
 340         Paragraph * tmp = parlist;
 341         while (tmp->next_par_)
 342                 tmp = tmp->next_par_;
 343         return *tmp;
 344 }
 345
 346
 347 Paragraph & ParagraphList::back()
 348 {
 349         Paragraph * tmp = parlist;
 350         while (tmp->next_par_)
 351                 tmp = tmp->next_par_;
 352         return *tmp;
 353 }
 354
 355
 356 void ParagraphList::push_back(Paragraph const & pr)
 357 {
 358         Paragraph * p = new Paragraph(pr);
 359
 360         if (!parlist) {
 361                 parlist = p;
 362                 return;
 363         }
 364
 365         Paragraph * pos = parlist;
 366         while (pos->next_par_)
 367                 pos = pos->next_par_;
 368         pos->next_par_ = p;
 369         p->prev_par_ = pos;
 370 }
 371
 372
 373 int ParagraphList::size() const
 374 {
 375         // When we switch to a std::container this will be O(1)
 376         // instead of O(n). (Lgb)
 377         Paragraph * tmp = parlist;
 378         int c = 0;
 379         while (tmp) {
 380                 ++c;
 381                 tmp = tmp->next_par_;
 382         }
 383         return c;
 384 }
 385
 386
 387 bool ParagraphList::empty() const
 388 {
 389         return parlist == 0;
 390 }
 391
 392 #endif