// The public inheritance should go in favour of a suitable data member
// (or maybe private inheritance) at some point of time.
-class DocIterator : public std::vector<CursorSlice>
+class DocIterator // : public std::vector<CursorSlice>
{
public:
/// type for cell number in inset
typedef CursorSlice::idx_type idx_type;
/// type for paragraph numbers positions within a cell
- typedef CursorSlice::par_type par_type;
+ typedef CursorSlice::pit_type pit_type;
/// type for cursor positions within a cell
typedef CursorSlice::pos_type pos_type;
/// type for row indices
///
explicit DocIterator(InsetBase & inset);
+ CursorSlice const & operator[](size_t i) const {
+ return slices_[i];
+ }
+
+ CursorSlice & operator[](size_t i) {
+ return slices_[i];
+ }
+
+ // What is the point of this function?
+ void resize(size_t i) { slices_.resize(i); }
+
/// is the iterator valid?
operator const void*() const { return empty() ? 0 : this; }
/// is this iterator invalid?
bool operator!() const { return empty(); }
+ bool empty() const { return slices_.empty(); }
+
//
// access to slice at tip
//
/// access to tip
- CursorSlice & top() { return back(); }
+ CursorSlice & top() { return slices_.back(); }
/// access to tip
- CursorSlice const & top() const { return back(); }
+ CursorSlice const & top() const { return slices_.back(); }
/// access to outermost slice
- CursorSlice & bottom() { return front(); }
+ CursorSlice & bottom() { return slices_.front(); }
/// access to outermost slicetip
- CursorSlice const & bottom() const { return front(); }
+ CursorSlice const & bottom() const { return slices_.front(); }
/// how many nested insets do we have?
- size_t depth() const { return size(); }
+ size_t depth() const { return slices_.size(); }
/// the containing inset
- InsetBase & inset() const { return back().inset(); }
+ InsetBase & inset() const { return top().inset(); }
/// return the cell of the inset this cursor is in
- idx_type idx() const { return back().idx(); }
+ idx_type idx() const { return top().idx(); }
/// return the cell of the inset this cursor is in
- idx_type & idx() { return back().idx(); }
+ idx_type & idx() { return top().idx(); }
/// return the last possible cell in this inset
idx_type lastidx() const;
/// return the paragraph this cursor is in
- par_type par() const { return back().par(); }
+ pit_type pit() const { return top().pit(); }
/// return the paragraph this cursor is in
- par_type & par() { return back().par(); }
+ pit_type & pit() { return top().pit(); }
/// return the last possible paragraph in this inset
- par_type lastpar() const;
+ pit_type lastpit() const;
/// return the position within the paragraph
- pos_type pos() const { return back().pos(); }
+ pos_type pos() const { return top().pos(); }
/// return the position within the paragraph
- pos_type & pos() { return back().pos(); }
+ pos_type & pos() { return top().pos(); }
/// return the last position within the paragraph
pos_type lastpos() const;
- /// return the display row of the cursor with in the top par
- row_type crow() const;
- /// return the display row of the cursor with in the top par
- row_type lastcrow() const;
/// return the number of embedded cells
size_t nargs() const;
/// the row in the paragraph we're in
Row const & textRow() const;
///
- LyXText * text() const;
+ LyXText * text();
+ ///
+ LyXText const * text() const;
///
InsetBase * innerInsetOfType(int code) const;
///
- LyXText * innerText() const;
+ LyXText * innerText();
+ ///
+ LyXText const * innerText() const;
//
// elementary moving
//
- /// move on one logical position
+ /// move on one logical position, do not descend into nested insets
+ void forwardPosNoDescend();
+ /// move on one logical position, descend into nested insets
void forwardPos();
/// move on one physical character or inset
void forwardChar();
/// output
friend std::ostream &
operator<<(std::ostream & os, DocIterator const & cur);
+ friend bool operator==(DocIterator const &, DocIterator const &);
+ friend class StableDocIterator;
+protected:
+ void clear() { slices_.clear(); }
+ void push_back(CursorSlice const & sl) {
+ slices_.push_back(sl);
+ }
+ void pop_back() {
+ slices_.pop_back();
+ }
private:
+ std::vector<CursorSlice> const & internalData() const {
+ return slices_;
+ }
+ std::vector<CursorSlice> slices_;
InsetBase * inset_;
};
DocIterator doc_iterator_end(InsetBase & inset);
+inline
+bool operator==(DocIterator const & di1, DocIterator const & di2)
+{
+ return di1.slices_ == di2.slices_;
+}
+
+
+inline
+bool operator!=(DocIterator const & di1, DocIterator const & di2)
+{
+ return !(di1 == di2);
+}
+
+
// The difference to a ('non stable') DocIterator is the removed
// (overwritte by 0...) part of the CursorSlice data items. So this thing
// is suitable for external storage, but not for iteration as such.