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