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 using lyx::par_type;
  22
  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--()
  57 {
  58 #ifdef WITH_WARNINGS
  59 #warning look here
  60 #endif
  61 //      DocIterator::backwardPar();
  62         return *this;
  63 }
  64
  65
  66 Paragraph & ParIterator::operator*() const
  67 {
  68         return text()->getPar(par());
  69 }
  70
  71
  72 par_type ParIterator::pit() const
  73 {
  74         return par();
  75 }
  76
  77
  78 Paragraph * ParIterator::operator->() const
  79 {
  80         return &text()->getPar(par());
  81 }
  82
  83
  84 par_type ParIterator::outerPar() const
  85 {
  86         return bottom().par();
  87 }
  88
  89
  90 ParagraphList & ParIterator::plist() const
  91 {
  92         return text()->paragraphs();
  93 }
  94
  95
  96 bool operator==(ParIterator const & iter1, ParIterator const & iter2)
  97 {
  98         return DocIterator(iter1) == DocIterator(iter2);
  99 }
 100
 101
 102 bool operator!=(ParIterator const & iter1, ParIterator const & iter2)
 103 {
 104         return !(iter1 == iter2);
 105 }
 106
 107
 108 DocIterator makeDocIterator(ParIterator const & par, lyx::pos_type pos)
 109 {
 110         DocIterator dit(par);
 111         dit.pos() = pos;
 112         return dit;
 113 }
 114
 115
 116
 117 ///
 118 /// ParConstIterator
 119 ///
 120
 121
 122 ParConstIterator::ParConstIterator(DocIterator const & dit)
 123         : DocIterator(dit)
 124 {}
 125
 126
 127 ParConstIterator::ParConstIterator(ParConstIterator const & pi)
 128         : DocIterator(DocIterator(pi))
 129 {}
 130
 131
 132 ParConstIterator & ParConstIterator::operator++()
 133 {
 134         DocIterator::forwardPar();
 135         return *this;
 136 }
 137
 138
 139 Paragraph const & ParConstIterator::operator*() const
 140 {
 141         return text()->getPar(par());
 142 }
 143
 144
 145 Paragraph const * ParConstIterator::operator->() const
 146 {
 147         return &text()->getPar(par());
 148 }
 149
 150
 151 ParagraphList const & ParConstIterator::plist() const
 152 {
 153         return text()->paragraphs();
 154 }
 155
 156
 157 bool operator==(ParConstIterator const & iter1, ParConstIterator const & iter2)
 158 {
 159         return DocIterator(iter1) == DocIterator(iter2);
 160 }
 161
 162
 163 bool operator!=(ParConstIterator const & iter1, ParConstIterator const & iter2)
 164 {
 165         return !(iter1 == iter2);
 166 }
 167
 168
 169 #warning const correctness!
 170
 171 ParConstIterator par_const_iterator_begin(InsetBase const & inset)
 172 {
 173         return ParConstIterator(doc_iterator_begin(const_cast<InsetBase &>(inset)));
 174 }
 175
 176
 177 ParConstIterator par_const_iterator_end(InsetBase const & inset)
 178 {
 179         return ParConstIterator(doc_iterator_end(const_cast<InsetBase &>(inset)));
 180 }