---

iterator.hh

/*
*  Name:         iterator.hh
*  Author:       Francisco Vides Fernandez
*  Contributor:  Rafael Jesus Alcantara Perez
*  Summary:      Definition of a general iterator template
*  Date:         $Date: 2003/10/06 13:21:35 $
*  Revision:     $Revision: 1.1 $
*
*  Copyright (C) 2000-2001  Francisco Vides Fernandez <pax@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _UESQL_ITERATOR__
#define _UESQL_ITERATOR__

#include <cstdio>
#include <iterator>
#include <mpcl/exceptions.hh>


namespace uesqlc
{

  template <typename TMyQuery>
  class TIterator :
    public std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>
  {

    public:
      
      typedef
        typename std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>::iterator_category 
        iterator_category;
      
      typedef
        typename std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>::value_type
        value_type;

      typedef
        typename std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>::difference_type
        difference_type;

      typedef
        typename std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>::pointer
        pointer;

      typedef
        typename std::iterator <std::input_iterator_tag, typename TMyQuery::value_type>::reference
        reference;
      

    protected:
      
      long int   liCurrent;

      TMyQuery*   ptQuery;


    private:
      
      TIterator (void)   :
        liCurrent (0)    , 
        ptQuery   (NULL) {}


    public:

      //
      //  C O N S T R U C T O R S
      //

      TIterator (const TIterator& rktIterator) :
        liCurrent (rktIterator.liCurrent)      , 
        ptQuery   (rktIterator.ptQuery)        {}

      TIterator (TMyQuery* ptQUERY) :
        liCurrent (0)               ,
        ptQuery   (ptQUERY)         {}
      
      TIterator& operator = (const TIterator& rktITERATOR)
      {
        liCurrent = rktITERATOR.liCurrent;
        ptQuery   = rktITERATOR.ptQuery;
        return *this;
      }

      TIterator& operator ++ (void)
      {
        liCurrent++;
        return *this;
      }

      TIterator operator ++ (int)
      {
        TIterator   tRet (*this);

        liCurrent++;
        return tRet;
      }

      std::size_t operator - (const TIterator& rktITERATOR) const
      {
        std::size_t   tRet;
        if ( liCurrent >= rktITERATOR.liCurrent )
        {
          tRet = liCurrent - rktITERATOR.liCurrent;
        }
        else
        {
          throw mpcl::TExceptionEL_Constraint ( "size constraint error in TIterator::operator - " ,
                                                __FILE__                                          ,
                                                __LINE__                                          );
        }
        return tRet; 
      }

      void setPastTheEnd (void)
      {
        liCurrent = ptQuery->size();
      }


    public:

      //
      //  S E L E C T O R S
      //
      
      bool isPastTheEnd (void) const
      {
        return liCurrent >= (long int) ptQuery->size();
      }

      bool operator == (const TIterator& rktITERATOR) const
      {
        bool   gRet = false;

        if ( ( isPastTheEnd() && rktITERATOR.isPastTheEnd() ) ||
             ( liCurrent == rktITERATOR.liCurrent )            )
        {
          gRet = true;
        }
        return gRet;
      }

      bool operator != (const TIterator& rktITERATOR) const
      {
        return !( operator == (rktITERATOR) );
      }

      pointer  operator -> () const
      {
        return &(operator*());
      }

      reference operator * (void) const
      {
        return (*ptQuery) [liCurrent];
      }

  };  // class TIterator

}  // namespace uesqlc


#endif  // _UESQL_ITERATOR__

---