RTSQLSelectRow_Impl.hh

//********************************************************************
//*** ResourcePool/SQL/RTSQLSelectRow_Impl.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: RTSQLSelectRow_Impl.hh,v 1.11 2008/05/19 07:50:24 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool 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.

ResourcePool 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 ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef RESOURCEPOOL_SQL_RTSQLSELECTROW_IMPL_HH
#define RESOURCEPOOL_SQL_RTSQLSELECTROW_IMPL_HH

#include "ResourcePool/SQL/RTSQLSelectRow.hh"
#include "ResourcePool/SQL/RTSQLExecute_Impl.hh"

namespace fatalmind {
namespace SQL {


template<class TM, template<class TM2>class B, class RT, class CW, class RTC>
class RTSQLSelectRow_SpecializedImpl
: public RTSQLExecute_SpecializedImpl<TM, B, RT, CW, RTC> 
{
        typedef RTSQLExecute_SpecializedImpl<TM, B, RT, CW, RTC> super;
        using super::sqlExecute_;
    public:
        RTSQLSelectRow_SpecializedImpl(RTC& rtc, const std::string& sql, SQL::SQLFetcher& fetcher)
        : super(rtc, sql, fetcher)
        {
        }

        virtual ~RTSQLSelectRow_SpecializedImpl() {
        }

        // would like to make a template..
        // .. but virtual templates doesn't exists
        virtual void bindout(const int pos, char& val, bool& isnull) {
            sqlExecute_.template bindout<char>(pos, val, isnull);
        }
        virtual void bindout(const int pos, char& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<char>(pos, val, notnull);
        }

        virtual void bindout(const int pos, signed char& val, bool& isnull) {
            sqlExecute_.template bindout<signed char>(pos, val, isnull);
        }
        virtual void bindout(const int pos, signed char& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<signed char>(pos, val, notnull);
        }

        virtual void bindout(const int pos, unsigned char& val, bool& isnull) {
            sqlExecute_.template bindout<unsigned char>(pos, val, isnull);
        }
        virtual void bindout(const int pos, unsigned char& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<unsigned char>(pos, val, notnull);
        }

        virtual void bindout(const int pos, short int& val, bool& isnull) {
            sqlExecute_.template bindout<short>(pos, val, isnull);
        }
        virtual void bindout(const int pos, short int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<short>(pos, val, notnull);
        }
        virtual void bindout(const int pos, int& val, bool& isnull) {
            sqlExecute_.template bindout<int>(pos, val, isnull);
        }
        virtual void bindout(const int pos, int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<int>(pos, val, notnull);
        }
        virtual void bindout(const int pos, long int& val, bool& isnull) {
            sqlExecute_.template bindout<long int>(pos, val, isnull);
        }
        virtual void bindout(const int pos, long int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<long int>(pos, val, notnull);
        }

        virtual void bindout(const int pos, unsigned short int& val, bool& isnull) {
            sqlExecute_.template bindout<unsigned short>(pos, val, isnull);
        }
        virtual void bindout(const int pos, unsigned short int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<unsigned short>(pos, val, notnull);
        }
        virtual void bindout(const int pos, unsigned int& val, bool& isnull) {
            sqlExecute_.template bindout<unsigned int>(pos, val, isnull);
        }
        virtual void bindout(const int pos, unsigned int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<unsigned int>(pos, val, notnull);
        }
        virtual void bindout(const int pos, unsigned long int& val, bool& isnull) {
            sqlExecute_.template bindout<unsigned long>(pos, val, isnull);
        }
        virtual void bindout(const int pos, unsigned long int& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<unsigned long>(pos, val, notnull);
        }

        virtual void bindout(const int pos, float& val, bool& isnull) {
            sqlExecute_.template bindout<float>(pos, val, isnull);
        }
        virtual void bindout(const int pos, float& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<float>(pos, val, notnull);
        }
        virtual void bindout(const int pos, double& val, bool& isnull) {
            sqlExecute_.template bindout<double>(pos, val, isnull);
        }
        virtual void bindout(const int pos, double& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<double>(pos, val, notnull);
        }
        virtual void bindout(const int pos, long double& val, bool& isnull) {
            sqlExecute_.template bindout<long double>(pos, val, isnull);
        }
        virtual void bindout(const int pos, long double& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<long double>(pos, val, notnull);
        }

        virtual void bindout(const int pos, std::string& val, bool& isnull) {
            sqlExecute_.template bindout<std::string>(pos, val, isnull);
        }
        virtual void bindout(const int pos, std::string& val, BindOutInterface::BindOutNotNullConstraint notnull) {
            sqlExecute_.template bindout<std::string>(pos, val, notnull);
        }

    protected:
        virtual Clone* DoClone() const {
            return new RTSQLSelectRow_SpecializedImpl<TM, B, RT, CW, RTC>(*this);
        }
};

} // namespace SQL
} // namespace fatalmind
#endif

---