Iterators.hpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : Iterators
 * Package    : Zeus.ZeusBase.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef IteratorsHPP
#define IteratorsHPP

#include <zeusbase/System/Interfaces/IListIterator.hpp>
#include <zeusbase/System/Interfaces/IMapIterator.hpp>
#include <zeusbase/System/AutoPtr.hpp>
#include <assert.h>

BEGIN_NAMESPACE_Zeus

/****************************************************************************/
/****************************************************************************/
template <class T> class TAbstractIterator : public TAutoPtrBase<IListIterator<T> >, private IListIterator<T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER reset() const
    {
      if (this->m_pInterface != NULL)
      {
        this->m_pInterface->reset();
      }
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual const T& MQUALIFIER getNextItemConst() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItemConst();
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual bool MQUALIFIER hasNextItem() const
    {
      bool bRetval = false;
      if (this->m_pInterface != NULL)
      {
        bRetval = this->m_pInterface->hasNextItem();
      }
      return bRetval;
    }
  
  protected:
    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractIterator()
     : TAutoPtrBase<IListIterator<T> >()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractIterator(const IListIterator<T>* pIt, bool bAllocPointer = false)
     : TAutoPtrBase<IListIterator<T> >(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractIterator(IListIterator<T>* pIt, bool bAllocPointer = false)
     : TAutoPtrBase<IListIterator<T> >(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItem() const = 0;

  private:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual Retval MQUALIFIER askForInterface(const InterfaceID& /*rInterfaceID*/, IZUnknown*& /*rpIface*/)
    {
      return RET_METHOD_NOT_IMPL;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER addRef() const {}

    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER release() const
    {}

    TAbstractIterator(const TAbstractIterator<T>& rIt);
    TAbstractIterator<T>& operator=(const TAbstractIterator<T>& rIt);
};

//############################################################################
//                                    LIST ITERATORS
/****************************************************************************/
/****************************************************************************/
template <class T> class TIterator : public TAbstractIterator<T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline TIterator()
     : TAbstractIterator<T>()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TIterator(IListIterator<T>* pIt, bool bAllocPointer = false)
     : TAbstractIterator<T>(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TIterator(const TIterator<T>& rIt)
     : TAbstractIterator<T>(rIt.m_pInterface, true)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TIterator<T>& operator=(const TIterator<T>& rIt)
    {
      this->assign(rIt.m_pInterface);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline TIterator<T>& operator=(IListIterator<T>* pIt)
    {
      this->attach(pIt);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const TIterator<T>& rWrapper) const
    {
      return this->equals(rWrapper.m_pInterface);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const IListIterator<T>* pIt) const
    {
      return this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const TIterator<T>& rWrapper) const
    {
      return !this->equals(rWrapper.m_pInterface);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const IListIterator<T>* pIt) const
    {
      return !this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItem() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItem();
    }

  private:
};

/****************************************************************************/
/****************************************************************************/
template <class T> class TConstIterator : public TAbstractIterator<T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline TConstIterator()
     : TAbstractIterator<T>()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstIterator(const IListIterator<T>* pIt, bool bAllocPointer = false)
     : TAbstractIterator<T>(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstIterator(const TConstIterator<T>& rIt)
     : TAbstractIterator<T>(rIt.m_pInterface, true)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstIterator<T>& operator=(const TConstIterator<T>& rIt)
    {
      this->assign(rIt.m_pInterface);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline TConstIterator<T>& operator=(const IListIterator<T>* pIt)
    {
      this->attach(pIt);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const TConstIterator<T>& rWrapper) const
    {
      return this->equals(rWrapper.m_pInterface);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const IListIterator<T>* pIt) const
    {
      return this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const TConstIterator<T>& rWrapper) const
    {
      return !this->equals(rWrapper.m_pInterface);
    }
  
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const IListIterator<T>* pIt) const
    {
      return !this->equals(pIt);
    }
  
  private:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItem() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItem();
    }
};

//############################################################################
//                                    MAP ITERATORS
/****************************************************************************/
/****************************************************************************/
template <class TKeyType, class T> class TAbstractMapIterator
  : public TAutoPtrBase<IMapIterator<TKeyType, T> >,
    private IMapIterator<TKeyType, T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER reset() const
    {
      if (this->m_pInterface != NULL)
      {
        this->m_pInterface->reset();
      }
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual const T& MQUALIFIER getNextItemConst() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItemConst();
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual bool MQUALIFIER hasNextItem() const
    {
      bool bRetval = false;
      if (this->m_pInterface != NULL)
      {
        bRetval = this->m_pInterface->hasNextItem();
      }
      return bRetval;
    }

    /*************************************************************************/
    /*************************************************************************/
    inline virtual Retval MQUALIFIER getNextKeyConst(TKeyType& rKey) const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextKeyConst(rKey);
    }

    /*************************************************************************/
    /*************************************************************************/
    inline virtual const T& MQUALIFIER getNextItemWithKeyConst(TKeyType& rKey) const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItemWithKeyConst(rKey);
    }
  
  protected:
    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractMapIterator()
     : TAutoPtrBase<IMapIterator<TKeyType, T> >()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractMapIterator(const IMapIterator<TKeyType, T>* pIt, bool bAllocPointer = false)
     : TAutoPtrBase<IMapIterator<TKeyType, T> >(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TAbstractMapIterator(IMapIterator<TKeyType, T>* pIt, bool bAllocPointer = false)
     : TAutoPtrBase<IMapIterator<TKeyType, T> >(pIt, bAllocPointer)
    {}

    virtual T& MQUALIFIER getNextItem() const = 0;
    virtual Retval MQUALIFIER getNextKey(TKeyType& rKey) =0;
    virtual T& MQUALIFIER getNextItemWithKey(TKeyType& rKey) const = 0;
  
  
  private:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual Retval MQUALIFIER askForInterface(const InterfaceID& /*rInterfaceID*/, IZUnknown*& /*rpIface*/)
    {
      return RET_METHOD_NOT_IMPL;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER addRef() const {}

    /***********************************************************************/
    /***********************************************************************/
    inline virtual void MQUALIFIER release() const
    {}
    
    TAbstractMapIterator(const TAbstractMapIterator<TKeyType, T>& rIt);
    TAbstractMapIterator<TKeyType, T>& operator=(const TAbstractMapIterator<TKeyType, T>& rIt);
};


/****************************************************************************/
/****************************************************************************/
template <class TKeyType, class T> class TMapIterator : public TAbstractMapIterator<TKeyType, T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline TMapIterator()
     : TAbstractMapIterator<TKeyType, T>()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TMapIterator(IMapIterator<TKeyType, T>* pIt, bool bAllocPointer = false)
     : TAbstractMapIterator<TKeyType, T>(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TMapIterator(const TMapIterator<TKeyType, T>& rIt)
     : TAbstractMapIterator<TKeyType, T>(rIt.m_pInterface, true)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TMapIterator<TKeyType, T>& operator=(const TMapIterator<TKeyType, T>& rIt)
    {
      this->assign(rIt.m_pInterface);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline TMapIterator<TKeyType, T>& operator=(IMapIterator<TKeyType, T>* pIt)
    {
      this->attach(pIt);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const TMapIterator<TKeyType, T>& rWrapper) const
    {
      return this->equals(rWrapper.m_pInterface);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const IMapIterator<TKeyType, T>* pIt) const
    {
      return this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const TMapIterator<TKeyType, T>& rWrapper) const
    {
      return !this->equals(rWrapper.m_pInterface);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const IMapIterator<TKeyType, T>* pIt) const
    {
      return !this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItem() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItem();
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual Retval MQUALIFIER getNextKey(TKeyType& rKey)
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextKey(rKey);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItemWithKey(TKeyType& rKey) const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItemWithKey(rKey);
    }

  private:
};


/****************************************************************************/
/****************************************************************************/
template <class TKeyType, class T> class TConstMapIterator : public TAbstractMapIterator<TKeyType, T>
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline TConstMapIterator()
     : TAbstractMapIterator<TKeyType, T>()
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstMapIterator(const IMapIterator<TKeyType, T>* pIt, bool bAllocPointer = false)
     : TAbstractMapIterator<TKeyType, T>(pIt, bAllocPointer)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstMapIterator(const TConstMapIterator<TKeyType, T>& rIt)
     : TAbstractMapIterator<TKeyType, T>(rIt.m_pInterface, true)
    {}

    /***********************************************************************/
    /***********************************************************************/
    inline TConstMapIterator<TKeyType, T>& operator=(const TConstMapIterator<TKeyType, T>& rIt)
    {
      this->assign(rIt.m_pInterface);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline TConstMapIterator<TKeyType, T>& operator=(const IMapIterator<TKeyType, T>* pIt)
    {
      this->attach(pIt);
      return *this;
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const TConstMapIterator<TKeyType, T>& rWrapper) const
    {
      return this->equals(rWrapper.m_pInterface);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline bool operator==(const IMapIterator<TKeyType, T>* pIt) const
    {
      return this->equals(pIt);
    }
    
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const TConstMapIterator<TKeyType, T>& rWrapper) const
    {
      return !this->equals(rWrapper.m_pInterface);
    }
  
    /***********************************************************************/
    /***********************************************************************/
    inline bool operator!=(const IMapIterator<TKeyType, T>* pIt) const
    {
      return !this->equals(pIt);
    }
  
  private:
    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItem() const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItem();
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual Retval MQUALIFIER getNextKey(TKeyType& rKey)
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextKey(rKey);
    }

    /***********************************************************************/
    /***********************************************************************/
    inline virtual T& MQUALIFIER getNextItemWithKey(TKeyType& rKey) const
    {
      assert(this->m_pInterface != NULL);
      return this->m_pInterface->getNextItemWithKey(rKey);
    }
};

END_NAMESPACE_Zeus

#endif