mapIteratorBase.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2018 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once


#include <vrfutil/iteratorBase.h>
#include <vlutil/vlPrint.h>
#include <map>

template<class K, class T> class DtMapIteratorBase
{
private:

   //default constructor is not allowed
   DtMapIteratorBase();

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

public:

   DtMapIteratorBase(const std::map<K, T*>& map) : myMap(map), myCursor(), myDirection(DtIteratorForward) { first(); };

   DtMapIteratorBase(const DtMapIteratorBase& orig)
      : myMap(orig.myMap), myCursor(orig.myCursor), myDirection(orig.myDirection) {};

   virtual ~DtMapIteratorBase() {};

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

   virtual bool empty() const { return myMap.empty(); }

   virtual const std::map<K, T*>& map() { return myMap; };

   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 = myMap.begin();
         break;

      case DtIteratorEnd:
         myCursor = myMap.end();
         if (!myMap.empty())
         {
            --myCursor;
         }
         break;

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

      myDirection = direction;

      return (myCursor != myMap.end());
   };

   virtual void reverse()
   {
      myDirection =
         ((myDirection == DtIteratorForward) ?
         DtIteratorReverse : DtIteratorForward);
   };

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

   virtual DtIteratorDirection direction() { return myDirection; };


public:

   virtual T* internalFirst(bool move = true)
   {
      if (myDirection == DtIteratorForward)
      {
         if (move)
         {
            reset();
         }

         if (myMap.empty())
         {
            return 0;
         }
         else
         {
            return myMap.begin()->second;
         }
      }
      else
      {
         if (move)
         {
            reset(true);
         }

         if (myMap.empty())
         {
            return 0;
         }
         else
         {
            return myMap.rbegin()->second;
         }
      }
   };

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

   virtual T* internalCurrent() const 
   {
      return (myCursor != myMap.end() ? myCursor->second : 0);
   };

   virtual T* internalNext(bool move = true)
   {
      if (myDirection == DtIteratorForward)
      {
         if (myCursor != myMap.end())
         {
            typename std::map<K, T*>::const_iterator nextItem = myCursor;
            ++nextItem;

            if (move)
            {
               myCursor = nextItem;
            }

            if (nextItem != myMap.end())
            {
               return nextItem->second;
            }
         }
      }
      else
      {
         if (myCursor != myMap.end())
         {
            typename std::map<K, T*>::const_iterator nextItem = myCursor;

            if (myCursor == myMap.begin())
            {
               nextItem = myMap.end();
            }
            else
            {
               --nextItem;
            }

            if (move)
            {
               myCursor = nextItem;
            }

            if (nextItem != myMap.end())
            {
               return nextItem->second;
            }
         }
      }

      return 0;
   };

   virtual T* internalLast(bool move = true)
   {
      if (myDirection == DtIteratorForward)
      {
         if (move)
         {
            reset(true);
         }

         if (myMap.empty())
         {
            return 0;
         }
         else
         {
            return myMap.rbegin()->second;
         }
      }
      else
      {
         if (move)
         {
            reset();
         }

         if (myMap.empty())
         {
            return 0;
         }
         else
         {
            return myMap.begin()->second;
         }
      }
   };


   virtual T* internalWrapNext(bool move = true)
   {
      if (myCursor == myMap.end() || myMap.empty())
      {
         return 0;
      }

      typename std::map<K, T*>::const_iterator tmpCursor = myCursor;

      if (myDirection == DtIteratorForward)
      {
         ++tmpCursor;
      }
      else
      {
         if (myCursor == myMap.begin())
         {
            tmpCursor = myMap.end();
         }
         else
         {
            --tmpCursor;
         }
      }

      if (tmpCursor == myMap.end())
      {
         if (myDirection == DtIteratorForward)
         {
            tmpCursor = myMap.begin();
         }
         else
         {
            tmpCursor = myMap.end();
            --tmpCursor;
         }
      }

      if (move)
      {
         myCursor = tmpCursor;
      }

      if (tmpCursor != myMap.end())
      {
         return tmpCursor->second;
      }

      return 0;
   };

   virtual T* internalPrev(bool move = true)
   {
      if (myDirection == DtIteratorForward)
      {
         if (myCursor != myMap.end())
         {
            typename std::map<K, T*>::const_iterator prevItem = myCursor;

            if (myCursor == myMap.begin())
            {
               prevItem = myMap.end();
            }
            else
            {
               --prevItem;
            }

            if (move)
            {
               myCursor = prevItem;
            }

            if (prevItem != myMap.end())
            {
               return prevItem->second;
            }
         }
      }
      else
      {
         if (myCursor != myMap.end())
         {
            typename std::map<K, T*>::const_iterator prevItem = myCursor;
            ++prevItem;

            if (move)
            {
               myCursor = prevItem;
            }

            if (prevItem != myMap.end())
            {
               return prevItem->second;
            }
         }
      }

      return 0;
   };

   virtual T* internalWrapPrev(bool move = true)
   {
      if (myCursor == myMap.end() || myMap.empty())
      {
         return 0;
      }

      typename std::map<K, T*>::const_iterator tmpCursor = myCursor;

      if (myDirection == DtIteratorForward)
      {
         if (myCursor == myMap.begin())
         {
            tmpCursor = myMap.end();
         }
         else
         {
            --tmpCursor;
         }
      }
      else
      {
         ++tmpCursor;
      }

      if (tmpCursor == myMap.end())
      {
         if (myDirection == DtIteratorForward)
         {
            tmpCursor = myMap.end();
            --tmpCursor;
         }
         else
         {
            tmpCursor = myMap.begin();
         }
      }

      if (move)
      {
         myCursor = tmpCursor;
      }

      if (tmpCursor != myMap.end())
      {
         return tmpCursor->second;
      }

      return 0;
   };

   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 std::map<K, T*>&                   myMap;
   typename std::map<K, T*>::const_iterator myCursor;
   DtIteratorDirection                      myDirection;

};