// 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(InsetBase & inset);
+ explicit DocIterator(InsetBase & inset);
/// is the iterator valid?
operator const void*() const { return empty() ? 0 : this; }
CursorSlice & top() { return back(); }
/// access to tip
CursorSlice const & top() const { return back(); }
- /// access to outermost slice
+ /// access to outermost slice
CursorSlice & bottom() { return front(); }
/// access to outermost slicetip
CursorSlice const & bottom() const { return front(); }
/// 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
/// 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, DocumentIterator const & cur);
+ operator<<(std::ostream & os, DocIterator const & cur);
private:
InsetBase * inset_;
};
-DocumentIterator doc_iterator_begin(InsetBase & inset);
-DocumentIterator doc_iterator_end(InsetBase & inset);
+DocIterator doc_iterator_begin(InsetBase & inset);
+DocIterator doc_iterator_end(InsetBase & inset);
-// The difference to a ('non stable') DocumentIterator is the removed
+// 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 StableDocumentIterator {
+class StableDocIterator {
public:
///
- StableDocumentIterator() {}
+ StableDocIterator() {}
/// non-explicit intended
- StableDocumentIterator(const DocumentIterator & it);
+ StableDocIterator(const DocIterator & it);
///
- DocumentIterator asDocumentIterator(InsetBase * start) const;
+ DocIterator asDocIterator(InsetBase * start) const;
///
size_t size() const { return data_.size(); }
///
friend std::ostream &
- operator<<(std::ostream & os, StableDocumentIterator const & cur);
+ operator<<(std::ostream & os, StableDocIterator const & cur);
///
friend std::istream &
- operator>>(std::istream & is, StableDocumentIterator & cur);
+ operator>>(std::istream & is, StableDocIterator & cur);
private:
std::vector<CursorSlice> data_;
};
-bool operator==(StableDocumentIterator const &, StableDocumentIterator const &);
+bool operator==(StableDocIterator const &, StableDocIterator const &);
#endif