get rid of broken_header.h and some unneeded tests

[lyx.git] / src / dociterator.h

diff --git a/src/dociterator.h b/src/dociterator.h
index baff5c690e86b8153b620e215d36fd3df1723d09..da4f082c0c1ec09f9ddb243e747d6d023d2692a4 100644 (file)
--- a/src/dociterator.h
+++ b/src/dociterator.h
@@ -34,13 +34,13 @@ 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
@@ -49,6 +49,16 @@ public:
        typedef CursorSlice::col_type col_type;
 
 public:
+       ///
+       DocIterator();
+       ///
+       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
        //
@@ -56,6 +66,10 @@ public:
        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
@@ -67,21 +81,17 @@ public:
        /// 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
        pos_type & pos() { return back().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;
@@ -150,50 +160,66 @@ public:
        //
        // 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, DocumentIterator const & cur);
+       operator<<(std::ostream & os, DocIterator const & cur);
+private:
+       InsetBase * inset_;
 };
 
 
-///
-DocumentIterator insetBegin(InsetBase & inset);
-///
-DocumentIterator insetEnd();
+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