iterator.hh

Go to the documentation of this file.

#ifndef __ITERATOR_HH__
#define __ITERATOR_HH__
 
#ifndef __INCLUDED_FROM_DW_CORE_HH__
#   error Do not include this file directly, use "core.hh" instead.
#endif
 
namespace dw {
namespace core {
 
class Iterator: public lout::object::Comparable
{
protected:
   Iterator(Widget *widget, Content::Type mask, bool atEnd);
   Iterator(Iterator &it);
   ~Iterator();
 
   Content content;
 
private:
   Widget *widget;
   Content::Type mask;
 
public:
   bool equals (Object *other);
   void intoStringBuffer(lout::misc::StringBuffer *sb);
 
   inline Widget *getWidget () { return widget; }
   inline Content *getContent () { return &content; }
   inline Content::Type getMask () { return mask; }
 
   virtual void unref ();
 
   virtual bool next () = 0;
 
   virtual bool prev () = 0;
 
   virtual void highlight (int start, int end, HighlightLayer layer) = 0;
 
   virtual void unhighlight (int direction, HighlightLayer layer) = 0;
 
   virtual void getAllocation (int start, int end, Allocation *allocation) = 0;
 
   inline Iterator *cloneIterator () { return (Iterator*)clone(); }
 
   static void scrollTo (Iterator *it1, Iterator *it2, int start, int end,
                         HPosition hpos, VPosition vpos);
};
 
 
class EmptyIterator: public Iterator
{
private:
   EmptyIterator (EmptyIterator &it);
 
public:
   EmptyIterator (Widget *widget, Content::Type mask, bool atEnd);
 
   lout::object::Object *clone();
   int compareTo(lout::object::Comparable *other);
   bool next ();
   bool prev ();
   void highlight (int start, int end, HighlightLayer layer);
   void unhighlight (int direction, HighlightLayer layer);
   void getAllocation (int start, int end, Allocation *allocation);
};
 
 
class TextIterator: public Iterator
{
private:
   const char *text;
 
   TextIterator (TextIterator &it);
 
public:
   TextIterator (Widget *widget, Content::Type mask, bool atEnd,
                 const char *text);
 
   int compareTo(lout::object::Comparable *other);
 
   bool next ();
   bool prev ();
   void getAllocation (int start, int end, Allocation *allocation);
};
 
 
class DeepIterator: public lout::object::Comparable
{
private:
   class Stack: public lout::container::typed::Vector<Iterator>
   {
   public:
      inline Stack (): lout::container::typed::Vector<Iterator> (4, false) { }
      ~Stack ();
      inline Iterator *getTop () { return get (size () - 1); }
      inline void push (Iterator *it) { put(it, -1); }
      inline void pop() { getTop()->unref (); remove (size () - 1); }
   };
 
   Stack stack;
 
   static Iterator *searchDownward (Iterator *it, Content::Type mask,
                                    bool fromEnd);
   static Iterator *searchSideward (Iterator *it, Content::Type mask,
                                    bool fromEnd);
 
   Content::Type mask;
   Content content;
   bool hasContents;
 
   inline DeepIterator () { }
 
   static Widget *getRespectiveParent (Widget *widget, Content::Type mask);
   inline Widget *getRespectiveParent (Widget *widget) {
      return getRespectiveParent (widget, mask);
   }
 
   static int getRespectiveLevel (Widget *widget, Content::Type mask);
   inline int getRespectiveLevel (Widget *widget) {
      return getRespectiveLevel (widget, mask);
   }
 
public:
   DeepIterator(Iterator *it);
   ~DeepIterator();
 
   lout::object::Object *clone ();
 
   DeepIterator *createVariant(Iterator *it);
   inline Iterator *getTopIterator () { return stack.getTop(); }
   inline Content *getContent () { return &content; }
 
   bool isEmpty ();
 
   bool next ();
   bool prev ();
   inline DeepIterator *cloneDeepIterator() { return (DeepIterator*)clone(); }
   int compareTo(lout::object::Comparable *other);
 
   inline void highlight (int start, int end, HighlightLayer layer)
   { stack.getTop()->highlight (start, end, layer); }
 
   inline void getAllocation (int start, int end, Allocation *allocation)
   { stack.getTop()->getAllocation (start, end, allocation); }
 
   inline void unhighlight (int direction, HighlightLayer layer)
   { stack.getTop()->unhighlight (direction, layer); }
 
   inline static void scrollTo (DeepIterator *it1, DeepIterator *it2,
                                int start, int end,
                                HPosition hpos, VPosition vpos)
   { Iterator::scrollTo(it1->stack.getTop(), it2->stack.getTop(),
                         start, end, hpos, vpos); }
};
 
class CharIterator: public lout::object::Comparable
{
public:
   // START and END must not clash with any char value
   // neither for signed nor unsigned char.
   enum { START = 257, END = 258 };
 
private:
   DeepIterator *it;
   int pos, ch;
 
   CharIterator ();
 
public:
   CharIterator (Widget *widget, bool followReferences);
   ~CharIterator ();
 
   lout::object::Object *clone();
   int compareTo(lout::object::Comparable *other);
 
   bool next ();
   bool prev ();
   inline int getChar() { return ch; }
   inline CharIterator *cloneCharIterator() { return (CharIterator*)clone(); }
 
   static void highlight (CharIterator *it1, CharIterator *it2,
                          HighlightLayer layer);
   static void unhighlight (CharIterator *it1, CharIterator *it2,
                            HighlightLayer layer);
 
   inline static void scrollTo (CharIterator *it1, CharIterator *it2,
                                HPosition hpos, VPosition vpos)
   { DeepIterator::scrollTo(it1->it, it2->it, it1->pos, it2->pos,
                            hpos, vpos); }
};
 
} // namespace core
} // namespace dw
 
#endif // __ITERATOR_HH__