src/pariterator.C

   1 /* \file pariterator.C
   2  * This file is part of LyX, the document processor.
   3  * Licence details can be found in the file COPYING.
   4  *
   5  * \author unknown
   6  * \author Lars Gullik Bjønnes
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "pariterator.h"
  14
  15 #include "ParagraphList_fwd.h"
  16 #include "paragraph.h"
  17 #include "lyxtext.h"
  18
  19 #include "insets/inset.h"
  20
  21
  22 namespace lyx {
  23
  24 ///
  25 /// ParIterator
  26 ///
  27
  28 ParIterator::ParIterator(DocIterator const & cur) : DocIterator(cur)
  29 {}
  30
  31
  32 ParIterator par_iterator_begin(InsetBase & inset)
  33 {
  34         return ParIterator(doc_iterator_begin(inset));
  35 }
  36
  37
  38 ParIterator par_iterator_end(InsetBase & inset)
  39 {
  40         return ParIterator(doc_iterator_end(inset));
  41 }
  42
  43
  44 ParIterator::ParIterator(ParIterator const & pi)
  45         : DocIterator(DocIterator(pi))
  46 {}
  47
  48
  49 ParIterator & ParIterator::operator++()
  50 {
  51         forwardPar();
  52         return *this;
  53 }
  54
  55
  56 ParIterator ParIterator::operator++(int)
  57 {
  58         ParIterator tmp(*this);
  59         forwardPar();
  60         return tmp;
  61 }
  62
  63
  64 #if 0
  65 // Unused member functions. Also having this makes ParIterator not be
  66 // an forward iterator anymore. So unless we change that, this function
  67 // should not be compiled/used. (Lgb)
  68 ParIterator & ParIterator::operator--()
  69 {
  70 #ifdef WITH_WARNINGS
  71 #warning look here
  72 #endif
  73 //      DocIterator::backwardPar();
  74         return *this;
  75 }
  76 #endif
  77
  78
  79 Paragraph & ParIterator::operator*() const
  80 {
  81         return const_cast<Paragraph&>(text()->getPar(pit()));
  82 }
  83
  84
  85 pit_type ParIterator::pit() const
  86 {
  87         return DocIterator::pit();
  88 }
  89
  90
  91 Paragraph * ParIterator::operator->() const
  92 {
  93         return const_cast<Paragraph*>(&text()->getPar(pit()));
  94 }
  95
  96
  97 pit_type ParIterator::outerPar() const
  98 {
  99         return bottom().pit();
 100 }
 101
 102
 103 ParagraphList & ParIterator::plist() const
 104 {
 105         return const_cast<ParagraphList&>(text()->paragraphs());
 106 }
 107
 108
 109 bool operator==(ParIterator const & iter1, ParIterator const & iter2)
 110 {
 111         return DocIterator(iter1) == DocIterator(iter2);
 112 }
 113
 114
 115 bool operator!=(ParIterator const & iter1, ParIterator const & iter2)
 116 {
 117         return !(iter1 == iter2);
 118 }
 119
 120
 121 DocIterator makeDocIterator(ParIterator const & par, pos_type pos)
 122 {
 123         DocIterator dit(par);
 124         dit.pos() = pos;
 125         return dit;
 126 }
 127
 128
 129
 130 ///
 131 /// ParConstIterator
 132 ///
 133
 134
 135 ParConstIterator::ParConstIterator(DocIterator const & dit)
 136         : DocIterator(dit)
 137 {}
 138
 139
 140 ParConstIterator::ParConstIterator(ParConstIterator const & pi)
 141         : DocIterator(DocIterator(pi))
 142 {}
 143
 144
 145 ParConstIterator & ParConstIterator::operator++()
 146 {
 147         DocIterator::forwardPar();
 148         return *this;
 149 }
 150
 151
 152 Paragraph const & ParConstIterator::operator*() const
 153 {
 154         return text()->getPar(pit());
 155 }
 156
 157
 158 Paragraph const * ParConstIterator::operator->() const
 159 {
 160         return &text()->getPar(pit());
 161 }
 162
 163
 164 ParagraphList const & ParConstIterator::plist() const
 165 {
 166         return text()->paragraphs();
 167 }
 168
 169
 170 bool operator==(ParConstIterator const & iter1, ParConstIterator const & iter2)
 171 {
 172         return DocIterator(iter1) == DocIterator(iter2);
 173 }
 174
 175
 176 bool operator!=(ParConstIterator const & iter1, ParConstIterator const & iter2)
 177 {
 178         return !(iter1 == iter2);
 179 }
 180
 181
 182 #ifdef WITH_WARNINGS
 183 #warning const correctness!
 184 #endif
 185
 186 ParConstIterator par_const_iterator_begin(InsetBase const & inset)
 187 {
 188         return ParConstIterator(doc_iterator_begin(const_cast<InsetBase &>(inset)));
 189 }
 190
 191
 192 ParConstIterator par_const_iterator_end(InsetBase const & inset)
 193 {
 194         return ParConstIterator(doc_iterator_end(const_cast<InsetBase &>(inset)));
 195 }
 196
 197
 198 } // namespace lyx