---

abstract_connection_manager.hh

/*
*  Name:      abstract_connection_manager.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Class for handling connections in C++.
*  Date:      $Date: 2003/10/06 13:21:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1999-2003  Rafael Jesus Alcantara Perez <rafa@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_ABSTRACT_CONNECTION_MANAGER__
#define _UESQL_ABSTRACT_CONNECTION_MANAGER__

#include <algorithm>
#include <mpcl/exceptions.hh>
#include <mpcl/text/string.hh>
#include <mpcl/util/collection/map.hh>
#ifdef _UESQL_DEBUG__
#include <mpcl/util/logging/log.hh>
#endif  // not _UESQL_DEBUG__
#include <queue>
#include <vector>
#include "defs.hh"


namespace uesqlc
{

  template <typename TItem>
  struct MUpdateFromBuffer : public std::unary_function<TItem, void>
  {

      void operator () (TItem* ptITEM) const
      {
        ptITEM->updateFromBuffer();
      }

  };  // struct MUpdateFromBuffer

  template <typename TItem>
  struct MWriteDebugInfo : public std::unary_function<TItem, void>
  {

      void operator () (TItem* ptITEM) const
      {
#       ifdef _UESQL_DEBUG__
        mpcl::util::logging::tLog << ", " << ptITEM->get();
#       endif  // not _UESQL_DEBUG__
      }

  };  // struct MWriteDebugInfo

  template <typename TConnectionData, typename TResult>
  class TAbstractConnectionManager : protected TSqlstateDescriptor
  {

    protected:

      typedef
        mpcl::util::collection::TMap<mpcl::text::TString, TConnectionData>
        TConnectionDataMap;

      mutable int   iUniqueOrdinal;

      TConnectionDataMap   tConnectionDataMap;

      TConnectionData*   ptCurrentConnection;

      std::queue<mpcl::text::TString>   tInputEmbeddedVariableQueue;

      std::vector<IType*>   tOutputEmbeddedVariableVector;

      mpcl::text::TString   yCurrentConnection;


    public:

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

      TAbstractConnectionManager (void)      :
        TSqlstateDescriptor           ()     ,
        iUniqueOrdinal                (0)    ,
        tConnectionDataMap            ()     ,
        ptCurrentConnection           (NULL) ,
        tInputEmbeddedVariableQueue   ()     ,
        tOutputEmbeddedVariableVector ()     ,
        yCurrentConnection            ()
      {
        initialize();
      }

      virtual ~TAbstractConnectionManager (void)
      {
        finish();
      }

      void bindConnection ( const mpcl::text::TString& rkyCONNECTION_NAME ,
                            TConnectionData&           rtCONNECTION       )
      {
        tConnectionDataMap.bind (rkyCONNECTION_NAME, rtCONNECTION);
      }

      virtual void diagnose (TResult tRESULT) = 0;

      void unbindConnection (const mpcl::text::TString kyCONNECTION_NAME)
      {

        bool                                    gIsCurrentConnection;
        typename TConnectionDataMap::iterator   I = tConnectionDataMap.find (kyCONNECTION_NAME);

        if ( I == tConnectionDataMap.end() )
        {
          throw mpcl::TConstraintException ("there is no such connection", __FILE__, __LINE__);
        }
        else
        {
          gIsCurrentConnection = ( ptCurrentConnection == &(I->second) );
          I->second.close();
          tConnectionDataMap.erase (I);
          if ( gIsCurrentConnection )
          {
            yCurrentConnection.erase();
            ptCurrentConnection = NULL;
          }
        }

      }  // unbindConnection()

      void unbindCurrentConnection (void)
      {
        if ( existsDefaultConnection() )
        {
          unbindConnection (yCurrentConnection);
        }
      }

      void unbindAllConnections (void)
      {
        while ( !tConnectionDataMap.empty() )
        {
          unbindConnection (tConnectionDataMap.begin()->first);
        }
      }

      virtual void clearQueues (void)
      {
        while ( !tInputEmbeddedVariableQueue.empty() )
        {
          tInputEmbeddedVariableQueue.pop();
        }
        tOutputEmbeddedVariableVector.clear();
      }

      virtual void clearResult (TResult tRESULT) = 0;

      virtual TResult execute (const mpcl::text::TString& rkySTATEMENT)
      {
        return execute (rkySTATEMENT.c_str());
      }

      virtual TResult execute ( const mpcl::text::TString& rkySTATEMENT       ,
                                const mpcl::text::TString& rkyCONNECTION_NAME )
      {
        return execute (rkySTATEMENT.c_str(), rkyCONNECTION_NAME.c_str());
      }

      virtual TResult execute (const char* pkcSTATEMENT) = 0;

      virtual TResult execute ( const char* pkcSTATEMENT       ,
                                const char* pkyCONNECTION_NAME ) = 0;

      virtual void executeClean (const char* pkcSTATEMENT)
      {
        clearResult (execute (pkcSTATEMENT));
      }

      virtual void finish (void)
      {
        unbindAllConnections();
        clearQueues();
        tConnectionDataMap.clear();
        yCurrentConnection.erase();
      }

      virtual IType* getFromOutputQueue (const size_t zINDEX) const
      {
        if ( zINDEX >= tOutputEmbeddedVariableVector.size() )
        {
          throw mpcl::TConstraintException ("out of range", __FILE__, __LINE__);
        }
        return tOutputEmbeddedVariableVector [zINDEX];
      }

      virtual void initialize (void) {}

      mpcl::text::TString instantiate (const char* pkcSTATEMENT);

      mpcl::text::TString instantiate (const mpcl::text::TString& rkySTATEMENT)
      {
        return instantiate (rkySTATEMENT.c_str());
      }

      virtual void pushOnInputQueue (const IType& rktEMBEDDED_VALUE)
      {
        tInputEmbeddedVariableQueue.push (rktEMBEDDED_VALUE.get());
      }

      virtual IType* popFromOutputQueue (void)
      {
        IType*   ptBaseType = tOutputEmbeddedVariableVector.back();

        tOutputEmbeddedVariableVector.pop_back();
        return ptBaseType;
      }

      virtual void pushOnOutputQueue (IType* ptSQL_DATA_TYPE)
      {
        tOutputEmbeddedVariableVector.push_back (ptSQL_DATA_TYPE);
      }

      void resetStatus (void)
      {
        //
        //  Condition:  successful completion
        //
        SQLCODE    = 0;
        SQLMESSAGE = "";
        SQLSTATE   = "00000";
      }

      void setCurrentConnection (const mpcl::text::TString& rkyCONNECTION_NAME);

      virtual void updateOutputVariables (void);


    public:

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

      TConnectionData& getCurrentConnectionData (void)
      {
        if ( ptCurrentConnection == NULL )
        {
          throw mpcl::TConstraintException ("there is no current connection", __FILE__, __LINE__);
        }
        return *ptCurrentConnection;
      }

      const mpcl::text::TString& currentConnectionName (void) const
      {
        return yCurrentConnection;
      }

      virtual bool existsDefaultConnection (void) const
      {
        return ( ptCurrentConnection != NULL );
      }

      bool isConnected (const mpcl::text::TString& rkyCONNECTION_NAME) const
      {
        return tConnectionDataMap.isBound (rkyCONNECTION_NAME);
      }

      bool isNotFoundCondition (void) const
      {
        return ( SQLSTATE == no_data::pkcNO_SUBCLASS );
      }

      bool isSqlerrorCondition (void) const
      {
        return ( SQLCODE < 0 );
      }

  };  // class TAbstractConnectionManager

}  // namespace uesqlc


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

template <typename TConnectionData, typename TResult>
inline mpcl::text::TString uesqlc::TAbstractConnectionManager<TConnectionData, TResult>::
instantiate (const char* pkcSTATEMENT)
{

  using mpcl::text::TString;

  register TString::size_type   zPatternOffset;
  TString                       yStatementInstance (pkcSTATEMENT);

  while ( !tInputEmbeddedVariableQueue.empty() )
  {
    if ( TString::npos == (zPatternOffset = yStatementInstance.find ("$z")) )
    {
      break;
    }
    else
    {
      yStatementInstance.replace (zPatternOffset, 2, tInputEmbeddedVariableQueue.front());
      tInputEmbeddedVariableQueue.pop();
    }
  }
  return yStatementInstance;

}  // instantiate()


template <typename TConnectionData, typename TResult>
inline void uesqlc::TAbstractConnectionManager<TConnectionData, TResult>::
setCurrentConnection (const mpcl::text::TString& rkyCONNECTION_NAME)
{

  if ( tConnectionDataMap.isBound (rkyCONNECTION_NAME) )
  {
    yCurrentConnection  = rkyCONNECTION_NAME;
    ptCurrentConnection = &(tConnectionDataMap [rkyCONNECTION_NAME]);
#   ifdef _UESQL_DEBUG__
    mpcl::util::logging::tLog << mpcl::util::logging::header << "SET CONNECTION '" << rkyCONNECTION_NAME << "';\n";
#   endif  // not _UESQL_DEBUG__
    resetStatus();
  }
  else
  {
    //
    //  Condition:           connection exception
    //  Class subcondition:  connection does not exist
    //
    SQLCODE    = -1;
    SQLMESSAGE = "";
    SQLSTATE   = "08003";
  }

}  // setCurrentConnection()


template <typename TConnectionData, typename TResult>
inline void uesqlc::TAbstractConnectionManager<TConnectionData, TResult>::
updateOutputVariables (void)
{

# ifdef _UESQL_DEBUG__
  using mpcl::util::logging::header;
  using mpcl::util::logging::tLog;
# endif  // not _UESQL_DEBUG__
  using std::for_each;

  for_each ( tOutputEmbeddedVariableVector.begin() ,
             tOutputEmbeddedVariableVector.end()   ,
             MUpdateFromBuffer<IType>()            );
# ifdef _UESQL_DEBUG__
  tLog << header << "FETCHED (";
  if ( !tOutputEmbeddedVariableVector.empty() )
  {
    tLog << tOutputEmbeddedVariableVector.front()->get();
    for_each ( tOutputEmbeddedVariableVector.begin() + 1 ,
               tOutputEmbeddedVariableVector.end()       ,
               MWriteDebugInfo<IType>()                  );
  }
  tLog << ");\n";
# endif  // not _UESQL_DEBUG__

}  // updateOutputVariables()


#endif  // not _UESQL_ABSTRACT_CONNECTION_MANAGER__

---