src/ParagraphList.C

   1 #include <config.h>
   2
   3 #include "ParagraphList.h"
   4
   5 #include "paragraph.h"
   6
   7 ////////// The ParagraphList::iterator
   8
   9 ParagraphList::iterator::iterator()
  10         : ptr(0)
  11 {}
  12
  13
  14 ParagraphList::iterator::iterator(Paragraph * p)
  15         : ptr(p)
  16 {}
  17
  18
  19 ParagraphList::iterator::reference
  20 ParagraphList::iterator::operator*()
  21 {
  22         return *ptr;
  23 }
  24
  25
  26 ParagraphList::iterator::pointer
  27 ParagraphList::iterator::operator->()
  28 {
  29         return ptr;
  30 }
  31
  32
  33 ParagraphList::iterator &
  34 ParagraphList::iterator::operator++()
  35 {
  36 #ifndef NO_NEXT
  37         ptr = ptr->next_;
  38 #else
  39         ptr = ptr->next_par_;
  40 #endif
  41         return *this;
  42 }
  43
  44
  45 ParagraphList::iterator
  46 ParagraphList::iterator::operator++(int)
  47 {
  48         iterator tmp = *this;
  49         ++*this;
  50         return tmp;
  51 }
  52
  53
  54 ParagraphList::iterator &
  55 ParagraphList::iterator::operator--()
  56 {
  57 #ifndef NO_NEXT
  58         ptr = ptr->previous_;
  59 #else
  60         ptr = ptr->prev_par_;
  61 #endif
  62         return *this;
  63 }
  64
  65
  66 ParagraphList::iterator
  67 ParagraphList::iterator::operator--(int)
  68 {
  69         iterator tmp = *this;
  70         --*this;
  71         return tmp;
  72 }
  73
  74
  75 bool operator==(ParagraphList::iterator const & i1,
  76                 ParagraphList::iterator const & i2)
  77 {
  78         return &(*const_cast<ParagraphList::iterator&>(i1))
  79             == &(*const_cast<ParagraphList::iterator&>(i2));
  80 }
  81
  82
  83 bool operator!=(ParagraphList::iterator const & i1,
  84                 ParagraphList::iterator const & i2)
  85 {
  86         return !(i1 == i2);
  87 }
  88
  89 //////////
  90 ////////// The ParagraphList proper
  91 //////////
  92
  93 ParagraphList::ParagraphList()
  94         : parlist(0)
  95 {}
  96
  97
  98 ParagraphList::ParagraphList(ParagraphList const & pl)
  99         : parlist(0)
 100 {
 101         // Deep copy.
 102         ParagraphList::iterator it = pl.begin();
 103         ParagraphList::iterator end = pl.end();
 104         for (; it != end; ++it) {
 105                 push_back(new Paragraph(*it, false));
 106         }
 107 }
 108
 109
 110 ParagraphList & ParagraphList::operator=(ParagraphList const & rhs)
 111 {
 112         ParagraphList tmp(rhs);
 113         std::swap(parlist, tmp.parlist);
 114         return *this;
 115 }
 116
 117
 118 ParagraphList::iterator
 119 ParagraphList::insert(ParagraphList::iterator it, Paragraph * par)
 120 {
 121 #ifndef NO_NEXT
 122         if (it != end()) {
 123                 Paragraph * prev = it->previous_;
 124                 par->next_ = &*it;
 125                 par->previous_ = prev;
 126                 prev->next_ = par;
 127                 it->previous_ = par;
 128         } else if (parlist == 0) {
 129                 parlist = par;
 130         } else {
 131                 // Find last par.
 132                 Paragraph * last = parlist;
 133                 while (last->next_)
 134                         last = last->next_;
 135                 last->next_ = par;
 136                 par->previous_ = last;
 137         }
 138         return iterator(par);
 139 #else
 140         if (it != end()) {
 141                 Paragraph * prev = it->prev_par_;
 142                 par->next_par_ = &*it;
 143                 par->prev_par_ = prev;
 144                 prev->next_par_ = par;
 145                 it->prev_par_= par;
 146         } else if (parlist == 0) {
 147                 parlist = par;
 148         } else {
 149                 // Find last par.
 150                 Paragraph * last = parlist;
 151                 while (last->next_par_)
 152                         last = last->next_par_;
 153                 last->next_par_ = par;
 154                 par->prev_par_ = last;
 155         }
 156         return iterator(par);
 157 #endif
 158 }
 159
 160
 161
 162 void ParagraphList::insert(iterator pos, iterator beg, iterator end)
 163 {
 164         for (; beg != end; ++beg) {
 165                 insert(pos, new Paragraph(*beg, false));
 166         }
 167 }
 168
 169
 170 void ParagraphList::assign(iterator beg, iterator end)
 171 {
 172         clear();
 173         for (; beg != end; ++beg) {
 174                 push_back(new Paragraph(*beg, false));
 175         }
 176 }
 177
 178
 179 void ParagraphList::splice(iterator pos, ParagraphList & pl)
 180 {
 181         if (pl.parlist == 0)
 182                 return;
 183
 184         Paragraph * first = pl.parlist;
 185         Paragraph * last = first;
 186 #ifndef NO_NEXT
 187         while (last->next_)
 188                 last = last->next_;
 189
 190         if (pos == end()) {
 191                 if (parlist == 0) {
 192                         parlist = first;
 193                 } else {
 194                         Paragraph * last_par = &back();
 195                         last_par->next_ = first;
 196                         first->previous_ = last_par;
 197                 }
 198         } else if (pos == begin()) {
 199                 last->next_ = parlist;
 200                 parlist->previous_ = last;
 201                 parlist = first;
 202         } else {
 203                 Paragraph * pos_par = &*pos;
 204                 Paragraph * before_pos = pos_par->previous_;
 205
 206                 before_pos->next_ = first;
 207                 first->previous_ = before_pos;
 208                 last->next_ = pos_par;
 209                 pos_par->previous_ = last;
 210         }
 211         pl.parlist = 0;
 212 #else
 213         while (last->next_par_)
 214                 last = last->next_par_;
 215
 216         if (pos == end()) {
 217                 if (parlist == 0) {
 218                         parlist = first;
 219                 } else {
 220                         Paragraph * last_par = &back();
 221                         last_par->next_par_ = first;
 222                         first->prev_par_ = last_par;
 223                 }
 224         } else if (pos == begin()) {
 225                 last->next_par_ = parlist;
 226                 parlist->prev_par_ = last;
 227                 parlist = first;
 228         } else {
 229                 Paragraph * pos_par = &*pos;
 230                 Paragraph * before_pos = pos_par->prev_par_;
 231
 232                 before_pos->next_par_ = first;
 233                 first->prev_par_ = before_pos;
 234                 last->next_par_ = pos_par;
 235                 pos_par->prev_par_ = last;
 236         }
 237         pl.parlist = 0;
 238 #endif
 239 }
 240
 241
 242 void ParagraphList::clear()
 243 {
 244 #ifndef NO_NEXT
 245         while (parlist) {
 246                 Paragraph * tmp = parlist->next_;
 247                 delete parlist;
 248                 parlist = tmp;
 249         }
 250 #else
 251         while (parlist) {
 252                 Paragraph * tmp = parlist->next_par_;
 253                 delete parlist;
 254                 parlist = tmp;
 255         }
 256 #endif
 257 }
 258
 259
 260 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator it)
 261 {
 262 #ifndef NO_NEXT
 263         Paragraph * prev = it->previous_;
 264         Paragraph * next = it->next_;
 265
 266         if (prev)
 267                 prev->next_ = next;
 268         else
 269                 parlist = next;
 270
 271         if (next)
 272                 next->previous_ = prev;
 273
 274         it->previous_ = 0;
 275         it->next_ = 0;
 276         delete &*it;
 277         return next;
 278 #else
 279         Paragraph * prev = it->prev_par_;
 280         Paragraph * next = it->next_par_;
 281
 282         if (prev)
 283                 prev->next_par_ = next;
 284         else
 285                 parlist = next;
 286
 287         if (next)
 288                 next->prev_par_ = prev;
 289
 290         delete &*it;
 291         return next;
 292 #endif
 293 }
 294
 295
 296 ParagraphList::iterator ParagraphList::erase(ParagraphList::iterator first,
 297                               ParagraphList::iterator last)
 298 {
 299         while (first != last) {
 300                 erase(first++);
 301         }
 302         return last;
 303 }
 304
 305
 306 ParagraphList::iterator ParagraphList::begin()
 307 {
 308         return iterator(parlist);
 309 }
 310
 311
 312 ParagraphList::iterator ParagraphList::begin() const
 313 {
 314         return iterator(parlist);
 315 }
 316
 317
 318 ParagraphList::iterator ParagraphList::end()
 319 {
 320         return iterator();
 321 }
 322
 323
 324 ParagraphList::iterator ParagraphList::end() const
 325 {
 326         return iterator();
 327 }
 328
 329
 330 Paragraph const & ParagraphList::front() const
 331 {
 332         return *parlist;
 333 }
 334
 335
 336 Paragraph & ParagraphList::front()
 337 {
 338         return *parlist;
 339 }
 340
 341
 342 Paragraph const & ParagraphList::back() const
 343 {
 344 #ifndef NO_NEXT
 345         Paragraph * tmp = parlist;
 346         while (tmp->next_)
 347                 tmp = tmp->next_;
 348         return *tmp;
 349 #else
 350         Paragraph * tmp = parlist;
 351         while (tmp->next_par_)
 352                 tmp = tmp->next_par_;
 353         return *tmp;
 354 #endif
 355 }
 356
 357
 358 Paragraph & ParagraphList::back()
 359 {
 360 #ifndef NO_NEXT
 361         Paragraph * tmp = parlist;
 362         while (tmp->next_)
 363                 tmp = tmp->next_;
 364         return *tmp;
 365 #else
 366         Paragraph * tmp = parlist;
 367         while (tmp->next_par_)
 368                 tmp = tmp->next_par_;
 369         return *tmp;
 370 #endif
 371 }
 372
 373
 374 void ParagraphList::set(Paragraph * p)
 375 {
 376         parlist = p;
 377 }
 378
 379
 380 void ParagraphList::push_back(Paragraph * p)
 381 {
 382 #ifndef NO_NEXT
 383         if (!parlist) {
 384                 parlist = p;
 385                 return;
 386         }
 387
 388         Paragraph * pos = parlist;
 389         while (pos->next_)
 390                 pos = pos->next_;
 391         pos->next_ = p;
 392         p->previous_ = pos;
 393 #else
 394         if (!parlist) {
 395                 parlist = p;
 396                 return;
 397         }
 398
 399         Paragraph * pos = parlist;
 400         while (pos->next_par_)
 401                 pos = pos->next_par_;
 402         pos->next_par_ = p;
 403         p->prev_par_ = pos;
 404 #endif
 405 }
 406
 407
 408 int ParagraphList::size() const
 409 {
 410 #ifndef NO_NEXT
 411         // When we switch to a std::container this will be O(1)
 412         // instead of O(n). (Lgb)
 413         Paragraph * tmp = parlist;
 414         int c = 0;
 415         while (tmp) {
 416                 ++c;
 417                 tmp = tmp->next_;
 418         }
 419         return c;
 420 #else
 421         // When we switch to a std::container this will be O(1)
 422         // instead of O(n). (Lgb)
 423         Paragraph * tmp = parlist;
 424         int c = 0;
 425         while (tmp) {
 426                 ++c;
 427                 tmp = tmp->next_par_;
 428         }
 429         return c;
 430 #endif
 431 }
 432
 433
 434 bool ParagraphList::empty() const
 435 {
 436         return parlist == 0;
 437 }