SQLType.hh

//********************************************************************
//*** ResourcePool/mysql/SQLType.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: SQLType.hh,v 1.15 2009-03-14 15:12:25 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_MYSQL_SQLTYPE_HH
#define RESOURCEPOOL_MYSQL_SQLTYPE_HH

#include <iostream>

#include "mm/gc_ptr.hh"

namespace fatalmind {
namespace mysql {

class SQLType: public usg_cnt_t<DefaultThreadedModel> {
    public:
        SQLType(bool nul = false) 
        : _nul(nul)
        {
        }
        virtual ~SQLType() 
        {
        }
    
        virtual bool needsquote() const = 0;    
        virtual void outputoperator(std::ostream&) const = 0;
        void setnull(bool nul = true) {
            _nul = nul;
        };
        bool isnull() const throw() {
            return _nul;
        }

    private:
        bool _nul;
};

template<typename T>
class SQLTypeImpl: public SQLType
{
    public:
        SQLTypeImpl<T>(const T& val, const bool nul = true);
        virtual ~SQLTypeImpl<T>();

        virtual bool needsquote() const;
        virtual void outputoperator(std::ostream&) const;
        
    private:
        T _val;
};

class SQLRefType: public usg_cnt_t<DefaultThreadedModel> {
    public:
        virtual ~SQLRefType() {
        }

        virtual void assign(const char*, const int len) = 0;
    protected:
        const void* _valptr;
};

template<typename T>
class SQLRefTypeImpl: public SQLRefType 
{
    public:
        SQLRefTypeImpl<T>(T& val, bool& isnull);
        virtual ~SQLRefTypeImpl<T>();
        virtual void assign(const char*, const int len);
    private:
        T& val;
        bool& isnull;
};

inline std::ostream& operator<<(std::ostream& os, const SQLType& val)
{
    val.outputoperator(os);
    return os;
}

} // namespace mysql
} // namespace fatalmind
#endif

---