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
  12 #include <config.h>
  13
  14
  15 #include "pariterator.h"
  16
  17 #include "ParagraphList_fwd.h"
  18 #include "paragraph.h"
  19 #include "lyxtext.h"
  20
  21 #include "insets/inset.h"
  22
  23 using lyx::par_type;
  24
  25 ///
  26 /// ParIterator
  27 ///
  28
  29 ParIterator::ParIterator(DocumentIterator const & cur) : DocumentIterator(cur)
  30 {}
  31
  32
  33 ParIterator par_iterator_begin(InsetBase & inset)
  34 {
  35         return ParIterator(doc_iterator_begin(inset));
  36 }
  37
  38
  39 ParIterator par_iterator_end(InsetBase & inset)
  40 {
  41         return ParIterator(doc_iterator_end(inset));
  42 }
  43
  44
  45 ParIterator::ParIterator(ParIterator const & pi)
  46         : DocumentIterator(DocumentIterator(pi))
  47 {}
  48
  49
  50 ParIterator & ParIterator::operator++()
  51 {
  52         forwardPar();
  53         return *this;
  54 }
  55
  56
  57 ParIterator & ParIterator::operator--()
  58 {
  59 //      DocumentIterator::backwardPar();
  60         return *this;
  61 }
  62
  63
  64 Paragraph & ParIterator::operator*() const
  65 {
  66         return text()->getPar(par());
  67 }
  68
  69
  70 par_type ParIterator::pit() const
  71 {
  72         return par();
  73 }
  74
  75
  76 Paragraph * ParIterator::operator->() const
  77 {
  78         return &text()->getPar(par());
  79 }
  80
  81
  82 par_type ParIterator::outerPar() const
  83 {
  84         return bottom().par();
  85 }
  86
  87
  88 ParagraphList & ParIterator::plist() const
  89 {
  90         return text()->paragraphs();
  91 }
  92
  93
  94 bool operator==(ParIterator const & iter1, ParIterator const & iter2)
  95 {
  96         return DocumentIterator(iter1) == DocumentIterator(iter2);
  97 }
  98
  99
 100 bool operator!=(ParIterator const & iter1, ParIterator const & iter2)
 101 {
 102         return !(iter1 == iter2);
 103 }
 104
 105 DocumentIterator
 106 makeDocumentIterator(ParIterator const & par, lyx::pos_type pos)
 107 {
 108         DocumentIterator dit(par);
 109         dit.pos() = pos;
 110         return dit;
 111 }
 112
 113 ///
 114 /// ParConstIterator
 115 ///
 116
 117
 118 ParConstIterator::ParConstIterator(DocumentIterator const & dit)
 119         : DocumentIterator(dit)
 120 {}
 121
 122
 123 ParConstIterator::ParConstIterator(ParConstIterator const & pi)
 124         : DocumentIterator(DocumentIterator(pi))
 125 {}
 126
 127
 128 ParConstIterator & ParConstIterator::operator++()
 129 {
 130         DocumentIterator::forwardPar();
 131         return *this;
 132 }
 133
 134
 135 Paragraph const & ParConstIterator::operator*() const
 136 {
 137         return text()->getPar(par());
 138 }
 139
 140
 141 Paragraph const * ParConstIterator::operator->() const
 142 {
 143         return &text()->getPar(par());
 144 }
 145
 146
 147 ParagraphList const & ParConstIterator::plist() const
 148 {
 149         return text()->paragraphs();
 150 }
 151
 152
 153 bool operator==(ParConstIterator const & iter1, ParConstIterator const & iter2)
 154 {
 155         return DocumentIterator(iter1) == DocumentIterator(iter2);
 156 }
 157
 158
 159 bool operator!=(ParConstIterator const & iter1, ParConstIterator const & iter2)
 160 {
 161         return !(iter1 == iter2);
 162 }
 163
 164
 165 #warning const correctness!
 166
 167 ParConstIterator par_const_iterator_begin(InsetBase const & inset)
 168 {
 169         return ParConstIterator(doc_iterator_begin(const_cast<InsetBase &>(inset)));
 170 }
 171
 172
 173 ParConstIterator par_const_iterator_end(InsetBase const & inset)
 174 {
 175         return ParConstIterator(doc_iterator_end(const_cast<InsetBase &>(inset)));
 176 }