iteratorBase.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2001 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: iteratorBase.h,v $ $Revision: 1.13 $ $State: Exp $
*******************************************************************************/
#ifndef iteratorBase_H_
#define iteratorBase_H_


#include <vlutil/vlList.h>
#include <vlutil/vlPrint.h>

enum DtIteratorLocation
{
   DtIteratorBeginning,
   DtIteratorEnd
};

enum DtIteratorDirection
{
   DtIteratorForward,
   DtIteratorReverse
};

template<class T> class DtIteratorBase
{
private:

   //default constructor is not allowed
   DtIteratorBase();

   const DtIteratorBase& operator=(const DtIteratorBase& orig);

public:

   DtIteratorBase(const DtList& list) : myList(list), myCursor(0), myDirection(DtIteratorForward) { first(); };

   DtIteratorBase(const DtIteratorBase& orig) : myList(orig.myList), myCursor(orig.myCursor), myDirection(orig.myDirection) {};

   virtual ~DtIteratorBase() {};

   virtual unsigned int size() const { return myList.count(); }

   virtual bool empty() const { return myList.count() == 0; }

   virtual const DtList& list() { return myList; };

   virtual bool reset(bool reverse = false)
      {
         return reset(
            (reverse ? DtIteratorEnd : DtIteratorBeginning),
            (reverse ? DtIteratorReverse : DtIteratorForward));
      };

   virtual bool reset(DtIteratorLocation location, 
      DtIteratorDirection direction = DtIteratorForward)
      {
         switch (location)
         {
         case DtIteratorBeginning:
            myCursor = myList.first();
            break;

         case DtIteratorEnd:
            myCursor = myList.last();
            break;

         default:
            DtWarn("DtIteratorBase::reset() unexpected location specified.\n");
         }

         myDirection = direction;

         return (myCursor != 0);
      };
   
   virtual void reverse()
      {
         myDirection =
            ((myDirection == DtIteratorForward) ?
            DtIteratorReverse :
            DtIteratorForward);
      };

   virtual void setDirection(DtIteratorDirection direction) 
      { myDirection = direction; };

   virtual DtIteratorDirection direction() { return myDirection; };

   virtual int cursorIndex() const
      {
         DtListItem* item = myList.first();
         int i = 0;

         for (;item; item = item->next(), i++)
         {
            if (item == myCursor)
            {
               return i;
            }
         }

         return -1;
      }

   virtual void setCursorIndex(int i)
      {
         myCursor = myList.first();

         if (i != -1)
         {
            while (i)
            {
               myCursor = myCursor->next();
               i--;
            }
         }
      }

public:

   virtual T* internalFirst(bool move = true)
      {
         if (myDirection == DtIteratorForward)
         {
            if (move)
            {
               reset();
            }
   
            if (myList.first())
            {
               return (T*)(myList.first()->data());
            }
            else
            {
               return 0;
            }
         }
         else
         {
            if (move)
            {
               reset(true);
            }

            if (myList.last())
            {
               return (T*)(myList.last()->data());
            }
            else
            {
               return 0;
            }
         }
      };

   T* operator->() { return current(); };
   T* operator*() { return current(); };

   virtual T* internalCurrent() const {return (myCursor ? (T*)myCursor->data() : 0); };

   virtual DtListItem* cursor() const { return myCursor; };

   virtual T* itemToObject(DtListItem* item, bool move)
      {
         if (move)
         {
            myCursor = item;
         }

         if (item)
         {
            return (T*)item->data();
         }

         return 0;
      };

   virtual T* internalNext(bool move = true)
      {
         if (myCursor)
         {

            DtListItem* tmpCursor = 0;

            tmpCursor = ((myDirection == DtIteratorForward) ?
               myCursor->next() : myCursor->prev());

            return itemToObject(tmpCursor, move);
         }
   
         return 0;
      };

   virtual T* internalLast(bool move = true)
      {
         if (myDirection == DtIteratorForward)
         {
            if (move)
            {
               reset(true);
            }
   
            if (myList.last())
            {
               return (T*)(myList.last()->data());
            }
            else
            {
               return 0;
            }
         }
         else
         {
            if (move)
            {
               reset();
            }
   
            if (myList.first())
            {
               return (T*)(myList.first()->data());
            }
            else
            {
               return 0;
            }
         }
      };


   virtual T* internalWrapNext(bool move = true)
      {
         if (!myCursor)
         {
            return 0;
         }

         DtListItem* tmpCursor = 0;

         tmpCursor = ((myDirection == DtIteratorForward) ?
            myCursor->next() : myCursor->prev());

         if (! tmpCursor)
         {
            tmpCursor = ((myDirection == DtIteratorForward) ?
               myList.first() : myList.last());
         }

         return itemToObject(tmpCursor, move);
      };

   virtual T* internalPrev(bool move = true)
      {
         if (myCursor)
         {
            DtListItem* tmpCursor = 0;

            tmpCursor = ((myDirection == DtIteratorForward) ?
               myCursor->prev() : myCursor->next());

            return itemToObject(tmpCursor, move);
         }

         return 0;
      };

   virtual T* internalWrapPrev(bool move = true)
      {
         if (!myCursor)
         {
            return 0;
         }

         DtListItem* tmpCursor = 0;

         tmpCursor = ((myDirection == DtIteratorForward) ?
            myCursor->prev() : myCursor->next());

         if (! tmpCursor)
         {
            tmpCursor = ((myDirection == DtIteratorForward) ?
               myList.last() : myList.first());
         }

         return itemToObject(tmpCursor, move);
      };

   virtual T* current() { return internalCurrent(); };
   virtual T* first(bool move = true) { return internalFirst(move); };
   virtual T* next(bool move = true) { return internalNext(move); };
   virtual T* prev(bool move = true) { return internalPrev(move); };
   virtual T* last(bool move = true) { return internalLast(move); };
   virtual T* wrapNext(bool move = true) { return internalWrapNext(move); };
   virtual T* wrapPrev(bool move = true) { return internalWrapPrev(move); };

   T* operator++() { return next(); };
   T* operator--() { return prev(); };

protected:

  const DtList&       myList;
  DtListItem*         myCursor;
  DtIteratorDirection myDirection;

};

#endif