---

query.hh

/*
*  Name:      query.hh
*  Author:    Francisco Vides Fernandez
*  Summary:   Definition of a general query class
*  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_QUERY__
#define _UESQL_QUERY__

#include <algorithm>
#include <cstdlib>
#include <mpcl/util/strategy/identifier_generator.hh>
#include <mpcl/util/collection/map.hh>
#include "iterator.hh"


namespace uesqlc
{

  template < typename TInstance                                                             ,
             typename TDataSource                                                           ,
             typename TObjectIdentifierFactory = mpcl::util::strategy::TIdentifierGenerator >
  class TQuery                         :
    protected TDataSource              ,
    public    TObjectIdentifierFactory
  {

    public:

      typedef
        TInstance
        value_type;

      typedef
        TInstance&
        reference;      

      typedef
        const TInstance&
        const_reference;      

      typedef
        TIterator<TQuery>
        iterator;

      typedef
        const TIterator<TQuery>
        const_iterator;

      typedef
        typename TIterator<TQuery>::difference_type
        difference_type;

      typedef
        typename TDataSource::size_type
        size_type;


    protected:

      bool   gIsDeclared;

      bool   gIsOpened;

      long int   liCurrent;

      long int   liTarget;

      mpcl::util::collection::TMap<long int, value_type>   tInstanceMap;

      value_type   tLastInstance;

      TString   yCursorName;

      size_type   zTupleCount;

      
    protected:

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

      void close (void)
      {
        if ( gIsOpened )
        {
          TDataSource::closeCursor (yCursorName);
          gIsOpened = false;
        }
      }
      
      void fetch (void)
      {
        if ( !gIsOpened )
        {
          open();
        }
        if ( liTarget != liCurrent )
        {
          TDataSource::setErrorException();
          if ( liTarget == liCurrent + 1 )
          {
            TDataSource::fetchNext (yCursorName, tLastInstance);
          }
          else
          {
            TDataSource::fetchAbsolute (yCursorName, tLastInstance, TInteger (liTarget));
          }
          liCurrent = liTarget;
          tInstanceMap.bind (liCurrent, tLastInstance);
        }
      }

      void open (void)
      {
        if ( gIsDeclared )
        {
          if ( gIsOpened )
          {
            close();
          }
        }
        else
        {
          zTupleCount = TDataSource::declareCursor (yCursorName);
        }
        TDataSource::openCursor (yCursorName);
        gIsDeclared = true;
        gIsOpened   = true;
      }


    public:

      //
      //  C O N S T R U C T O R S  
      //
      
      TQuery (void)                            :
        gIsDeclared   (false)                  ,
        gIsOpened     (false)                  ,
        liCurrent     (-1)                     ,
        liTarget      (0)                      ,
        tInstanceMap  ()                       ,
        tLastInstance ()                       ,
        yCursorName   (_getObjectIdentifier()) ,
        zTupleCount   (0)                      {}

      TQuery (const TQuery& rktQUERY)          :
        gIsDeclared   (false)                  ,
        gIsOpened     (false)                  ,
        liCurrent     (rktQUERY.liCurrent)     ,
        liTarget      (rktQUERY.liTarget)      ,
        tInstanceMap  (rktQUERY.tInstanceMap)  ,
        tLastInstance (rktQUERY.tLastInstance) ,
        yCursorName   (_getObjectIdentifier()) ,
        zTupleCount   (rktQUERY.zTupleCount)   {}

      virtual ~TQuery (void) {}

      iterator begin (void)
      {
        iterator tRet (this);

        return tRet;
      }

      iterator end (void)
      {
        iterator tRet (this);

        tRet.setPastTheEnd();
        return tRet;
      }

      TQuery& operator = (const TQuery& rktQUERY)
      {
        gIsDeclared   = false;
        gIsOpened     = false;
        liCurrent     = rktQUERY.liCurrent;
        liTarget      = rktQUERY.liTarget;
        zTupleCount   = rktQUERY.zTupleCount;
        tInstanceMap  = rktQUERY.tInstanceMap;
        tLastInstance = rktQUERY.tLastInstance;
        yCursorName   = _getObjectIdentifier();
        return *this;
      }
      
      void swap (TQuery&) {}

      
    protected :

      //
      //  S E L E C T O R S
      //

      static mpcl::text::TString _getObjectIdentifier (void)
      {
        mpcl::text::TString   yRet = mpcl::text::Format ("cursor_%lu", _luiCounter);

        _luiCounter++;
        return yRet;
      }


    public:

      //
      //  S E L E C T O R S
      //

      bool empty (void) const
      {
        return ( size() == 0 );
      }

      size_type max_size (void) const
      {
        return size_type (-1);
      }

      bool operator == (const TQuery& rktQUERY) const
      {
        bool   gRet = false;
        
        if ( size() == rktQUERY.size() )
        {
          gRet = std::equal<iterator, iterator> (begin(), end(), rktQUERY.begin());
        }
        return gRet;
      }

      bool operator != (const TQuery& rktQUERY) const
      {
        return !(operator == (rktQUERY));
      }

      bool operator < (const TQuery& rktQUERY) const
      {
        return
          std::lexicographical_compare<iterator, iterator>
          (
            begin()          ,
            end()            ,
            rktQUERY.begin() ,
            rktQUERY.end()
          );
      }

      bool operator > (const TQuery& rktQUERY) const
      {
        return rktQUERY < *this;
      }

      bool operator <= (const TQuery& rktQUERY) const
      {
        return !(operator > (rktQUERY));
      }

      bool operator >= (const TQuery& rktQUERY) const
      {
        return !(operator < (rktQUERY));
      }

      size_type size (void)
      {
        if ( !gIsDeclared )
        {
          zTupleCount = TDataSource::declareCursor (yCursorName);
          gIsDeclared = true;
        }
        return zTupleCount;
      }

      reference operator [] (long int liITEM)
      {
        if ( !tInstanceMap.isBound (liITEM) )
        {
          liTarget = liITEM;
          fetch();
        }
        return tInstanceMap [liITEM];
      }

      const_reference operator [] (long int liITEM) const
      {
        if ( !tInstanceMap.isBound (liITEM) )
        {
          liTarget = liITEM;
          fetch();
        }
        return tInstanceMap [liITEM];
      }
      
  };  // class TQuery

}  // namespace uesqlc


namespace std
{

  template < typename TIterator                ,
             typename TDataSource              ,
             typename TObjectIdentifierFactory >
  inline void swap
  (
    uesqlc::TQuery<TIterator, TDataSource, TObjectIdentifierFactory>& rtQUERY1 ,
    uesqlc::TQuery<TIterator, TDataSource, TObjectIdentifierFactory>& rtQUERY2
  )
  {
    rtQUERY1.swap (rtQUERY2);
  }

}  // namespace std


#endif  // not _UESQL_QUERY__

---