#include "cursor_slice.h"
#include <vector>
+#include <iosfwd>
-class BufferView;
-class MathAtom;
class LyXText;
+class MathAtom;
class Paragraph;
class Row;
+
// only needed for gcc 2.95, remove when support terminated
template <typename A, typename B>
bool ptr_cmp(A const * a, B const * b)
// The public inheritance should go in favour of a suitable data member
// (or maybe private inheritance) at some point of time.
-class DocumentIterator : 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
public:
///
- DocumentIterator();
+ DocIterator();
///
- explicit DocumentIterator(BufferView & bv);
- ///
- BufferView & bv() const { return *bv_; }
+ explicit DocIterator(InsetBase & inset);
+
+ /// is the iterator valid?
+ operator const void*() const { return empty() ? 0 : this; }
+ /// is this iterator invalid?
+ bool operator!() const { return empty(); }
//
// access to slice at tip
CursorSlice & top() { return back(); }
/// access to tip
CursorSlice const & top() const { return back(); }
+ /// access to outermost slice
+ CursorSlice & bottom() { return front(); }
+ /// access to outermost slicetip
+ CursorSlice const & bottom() const { return front(); }
/// how many nested insets do we have?
size_t depth() const { return size(); }
/// the containing inset
- InsetBase * inset() const { return back().inset(); }
+ InsetBase & inset() const { return back().inset(); }
/// return the cell of the inset this cursor is in
idx_type idx() const { return back().idx(); }
/// return the cell of the inset this cursor is in
/// 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 back().pit(); }
/// return the paragraph this cursor is in
- par_type & par() { return back().par(); }
+ pit_type & pit() { return back().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(); }
/// return the position within the paragraph
///
LyXText * text() const;
///
- CursorSlice const & innerTextSlice() const;
- ///
InsetBase * innerInsetOfType(int code) const;
///
LyXText * innerText() const;
//
// elementary moving
//
- /// move on one position
+ /// move on one logical position
void forwardPos();
+ /// move on one physical character or inset
+ void forwardChar();
/// move on one paragraph
void forwardPar();
/// move on one cell
void forwardIdx();
/// move on one inset
void forwardInset();
-
+ /// move backward one logical position
+ void backwardPos();
+ /// move backward one physical character or inset
+ void backwardChar();
+ /// move backward one paragraph
+ void backwardPar();
+ /// move backward one cell
+ void backwardIdx();
+ /// move backward one inset
+ void backwardInset();
+
+ /// are we some 'extension' (i.e. deeper nested) of the given iterator
+ bool hasPart(DocIterator const & it) const;
+
+ /// output
+ friend std::ostream &
+ operator<<(std::ostream & os, DocIterator const & cur);
private:
- ///
- BufferView * bv_;
+ InsetBase * inset_;
};
-///
-DocumentIterator bufferBegin(BufferView & bv);
-///
-DocumentIterator bufferEnd();
-///
-DocumentIterator insetBegin(BufferView & bv, InsetBase * inset);
-///
-DocumentIterator insetEnd();
+DocIterator doc_iterator_begin(InsetBase & inset);
+DocIterator doc_iterator_end(InsetBase & inset);
+
+
+// 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.
+
+class StableDocIterator {
+public:
+ ///
+ StableDocIterator() {}
+ /// non-explicit intended
+ StableDocIterator(const DocIterator & it);
+ ///
+ DocIterator asDocIterator(InsetBase * start) const;
+ ///
+ size_t size() const { return data_.size(); }
+ ///
+ friend std::ostream &
+ operator<<(std::ostream & os, StableDocIterator const & cur);
+ ///
+ friend std::istream &
+ operator>>(std::istream & is, StableDocIterator & cur);
+private:
+ std::vector<CursorSlice> data_;
+};
+
+bool operator==(StableDocIterator const &, StableDocIterator const &);
#endif