+
#include <config.h>
#include "math_iterator.h"
+#include "math_inset.h"
#include "debug.h"
#include "support/LAssert.h"
-//MathIterator::MathIterator()
-//{}
+MathIterator::MathIterator()
+{}
MathIterator::MathIterator(MathInset * p)
}
-//MathIterator::MathIterator(MathCursor::cursor_type const & c)
-// : cursor_(c)
-//{}
-
-
-MathCursor::cursor_type const & MathIterator::cursor() const
-{
- return cursor_;
-}
-
-
-MathInset const * MathIterator::par() const
+MathInset const * MathIterator::inset() const
{
- return position().par_;
+ return back().inset_;
}
-MathInset * MathIterator::par()
+MathInset * MathIterator::inset()
{
- return position().par_;
+ return back().inset_;
}
MathArray const & MathIterator::cell() const
{
- MathCursorPos const & top = position();
- return top.par_->cell(top.idx_);
+ CursorPos const & top = back();
+ return top.inset_->cell(top.idx_);
}
void MathIterator::push(MathInset * p)
{
//lyxerr << "push: " << p << endl;
- cursor_.push_back(MathCursorPos(p));
+ push_back(CursorPos(p));
}
void MathIterator::pop()
{
//lyxerr << "pop: " << endl;
- lyx::Assert(cursor_.size());
- cursor_.pop_back();
+ lyx::Assert(size());
+ pop_back();
}
-MathCursorPos const & MathIterator::operator*() const
+CursorPos const & MathIterator::operator*() const
{
- return position();
+ return back();
}
-MathCursorPos const & MathIterator::operator->() const
+CursorPos const & MathIterator::operator->() const
{
- return position();
+ return back();
}
void MathIterator::goEnd()
{
- MathCursorPos & top = position();
- top.idx_ = top.par_->nargs() - 1;
+ CursorPos & top = back();
+ top.idx_ = top.inset_->nargs() - 1;
top.pos_ = cell().size();
}
void MathIterator::operator++()
{
- MathCursorPos & top = position();
- MathArray const & ar = top.par_->cell(top.idx_);
+ CursorPos & top = back();
+ MathArray & ar = top.inset_->cell(top.idx_);
// move into the current inset if possible
// it is impossible for pos() == size()!
return;
}
- // otherwise move on one cell position if possible
+ // otherwise move on one cell back if possible
if (top.pos_ < ar.size()) {
// pos() == size() is valid!
++top.pos_;
}
// otherwise try to move on one cell if possible
- while (top.idx_ + 1 < top.par_->nargs()) {
+ while (top.idx_ + 1 < top.inset_->nargs()) {
// idx() == nargs() is _not_ valid!
++top.idx_;
- if (top.par_->validCell(top.idx_)) {
+ if (top.inset_->validCell(top.idx_)) {
top.pos_ = 0;
return;
}
}
- // otherwise leave array, move on one position
+ // otherwise leave array, move on one back
// this might yield pos() == size(), but that's a ok.
pop();
// it certainly invalidates top
- ++position().pos_;
+ ++back().pos_;
+}
+
+
+void MathIterator::jump(difference_type i)
+{
+ back().pos_ += i;
+ //lyx::Assert(back().pos_ >= 0);
+ lyx::Assert(back().pos_ <= cell().size());
+}
+
+
+bool MathIterator::normal() const
+{
+ return back().pos_ < cell().size();
}
-void MathIterator::jump(MathInset::difference_type i)
+void MathIterator::shrink(size_type i)
{
- position().pos_ += i;
- //lyx::Assert(position().pos_ >= 0);
- lyx::Assert(position().pos_ <= cell().size());
+ if (i < size())
+ erase(begin() + i, end());
}
bool operator==(MathIterator const & it, MathIterator const & jt)
{
- //lyxerr << "==: " << it.cursor().size() << " " << jt.cursor().size() << endl;
- if (it.cursor().size() != jt.cursor().size())
- return false;
- return it.cursor() == jt.cursor();
+ return MathIterator::base_type(it) == MathIterator::base_type(jt);
}
bool operator!=(MathIterator const & it, MathIterator const & jt)
{
- //lyxerr << "!=: " << it.cursor().size() << " " << jt.cursor().size() << endl;
- if (it.cursor().size() != jt.cursor().size())
- return true;
- return it.cursor() != jt.cursor();
+ return MathIterator::base_type(it) != MathIterator::base_type(jt);
}