src/RowList.C

   1 #include <config.h>
   2
   3 #include "RowList.h"
   4
   5 #include "lyxrow.h"
   6
   7 ////////// The RowList::iterator
   8
   9 RowList::iterator::iterator()
  10         : ptr(0)
  11 {}
  12
  13
  14 RowList::iterator::iterator(Row * p)
  15         : ptr(p)
  16 {}
  17
  18
  19 RowList::iterator::reference
  20 RowList::iterator::operator*()
  21 {
  22         return *ptr;
  23 }
  24
  25
  26 RowList::iterator::pointer
  27 RowList::iterator::operator->()
  28 {
  29         return ptr;
  30 }
  31
  32
  33 RowList::iterator &
  34 RowList::iterator::operator++()
  35 {
  36         ptr = ptr->next();
  37         return *this;
  38 }
  39
  40
  41 RowList::iterator
  42 RowList::iterator::operator++(int)
  43 {
  44         iterator tmp = *this;
  45         ++*this;
  46         return tmp;
  47 }
  48
  49
  50 RowList::iterator &
  51 RowList::iterator::operator--()
  52 {
  53         ptr = ptr->previous();
  54         return *this;
  55 }
  56
  57
  58 RowList::iterator
  59 RowList::iterator::operator--(int)
  60 {
  61         iterator tmp = *this;
  62         --*this;
  63         return tmp;
  64 }
  65
  66
  67 bool operator==(RowList::iterator const & i1,
  68                 RowList::iterator const & i2)
  69 {
  70         return &(*const_cast<RowList::iterator&>(i1))
  71             == &(*const_cast<RowList::iterator&>(i2));
  72 }
  73
  74
  75 bool operator!=(RowList::iterator const & i1,
  76                 RowList::iterator const & i2)
  77 {
  78         return !(i1 == i2);
  79 }
  80
  81
  82 ////////// The RowList proper
  83 RowList::RowList()
  84         : rowlist(0)
  85 {}
  86
  87
  88 RowList::iterator
  89 RowList::insert(RowList::iterator it, Row * row)
  90 {
  91         if (rowlist == 0) {
  92                 rowlist = row;
  93         } else if (it != end()) {
  94                 Row * prev = it->previous();
  95                 row->next(&*it);
  96                 row->previous(prev);
  97                 if (prev)
  98                         prev->next(row);
  99                 else
 100                         rowlist = row;
 101                 it->previous(row);
 102         } else {
 103                 // Find last par.
 104                 Row * last = rowlist;
 105                 while (last->next())
 106                         last = last->next();
 107                 last->next(row);
 108                 row->previous(last);
 109         }
 110         return iterator(row);
 111 }
 112
 113
 114 void RowList::clear()
 115 {
 116         while (rowlist) {
 117                 Row * tmp = rowlist->next();
 118                 delete rowlist;
 119                 rowlist = tmp;
 120         }
 121 }
 122
 123
 124 void RowList::erase(RowList::iterator it)
 125 {
 126         Row * prev = it->previous();
 127         Row * next = it->next();
 128
 129         if (prev)
 130                 prev->next(next);
 131         else
 132                 rowlist = next;
 133
 134         if (next)
 135                 next->previous(prev);
 136
 137         delete &*it;
 138 }
 139
 140
 141 RowList::iterator RowList::begin()
 142 {
 143         return iterator(rowlist);
 144 }
 145
 146
 147 RowList::iterator RowList::begin() const
 148 {
 149         return iterator(rowlist);
 150 }
 151
 152
 153 RowList::iterator RowList::end()
 154 {
 155         return iterator();
 156 }
 157
 158
 159 RowList::iterator RowList::end() const
 160 {
 161         return iterator();
 162 }
 163
 164
 165 Row const & RowList::front() const
 166 {
 167         return *rowlist;
 168 }
 169
 170
 171 Row & RowList::front()
 172 {
 173         return *rowlist;
 174 }
 175
 176
 177 Row const & RowList::back() const
 178 {
 179         Row * tmp = rowlist;
 180         while (tmp->next())
 181                 tmp = tmp->next();
 182         return *tmp;
 183 }
 184
 185
 186 Row & RowList::back()
 187 {
 188         Row * tmp = rowlist;
 189         while (tmp->next())
 190                 tmp = tmp->next();
 191         return *tmp;
 192 }
 193
 194
 195 void RowList::set(Row * p)
 196 {
 197         rowlist = p;
 198 }
 199
 200
 201 void RowList::push_back(Row * p)
 202 {
 203         if (!rowlist) {
 204                 rowlist = p;
 205                 return;
 206         }
 207
 208         Row * pos = rowlist;
 209         while (pos->next())
 210                 pos = pos->next();
 211         pos->next(p);
 212         p->previous(pos);
 213 }
 214
 215
 216 int RowList::size() const
 217 {
 218         // When we switch to a std::container this will be O(1)
 219         // instead of O(n). (Lgb)
 220         Row * tmp = rowlist;
 221         int c = 0;
 222         while (tmp) {
 223                 ++c;
 224                 tmp = tmp->next();
 225         }
 226         return c;
 227 }
 228
 229
 230 bool RowList::empty() const
 231 {
 232         return rowlist == 0;
 233 }