MySQL++ Reference Manual

Main Page Namespace List Class Hierarchy Compound List File List Namespace Members Compound Members File Members

# coldata.h

Go to the documentation of this file.

    00001
    00002
    00003
    00004
    00005
    00006
    00007
    00008 /***********************************************************************
    00009  Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
    00010  MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
    00011  Others may also hold copyrights on code in this file.  See the CREDITS
    00012  file in the top directory of the distribution for details.
    00013
    00014  This file is part of MySQL++.
    00015
    00016  MySQL++ is free software; you can redistribute it and/or modify it
    00017  under the terms of the GNU Lesser General Public License as published
    00018  by the Free Software Foundation; either version 2.1 of the License, or
    00019  (at your option) any later version.
    00020
    00021  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
    00022  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    00023  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
    00024  License for more details.
    00025
    00026  You should have received a copy of the GNU Lesser General Public
    00027  License along with MySQL++; if not, write to the Free Software
    00028  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
    00029  USA
    00030 ***********************************************************************/
    00031
    00032 #ifndef MYSQLPP_COLDATA_H
    00033 #define MYSQLPP_COLDATA_H
    00034
    00035 #include "platform.h"
    00036
    00037 #include "const_string.h"
    00038 #include "convert.h"
    00039 #include "defs.h"
    00040 #include "exceptions.h"
    00041 #include "null.h"
    00042 #include "string_util.h"
    00043 #include "type_info.h"
    00044
    00045 #include <mysql.h>
    00046
    00047 #include <typeinfo>
    00048 #include <string>
    00049
    00050 #include <stdlib.h>
    00051
    00052 namespace mysqlpp {
    00053
    00084
    00085 template <class Str>
    00086 class ColData_Tmpl : public Str
    00087 {
    00088 public:
    00096         ColData_Tmpl() :
    00097         null_(false)
    00098         {
    00099         }
    00100
    00106         explicit ColData_Tmpl(bool n,
    00107                         mysql_type_info t = mysql_type_info::string_type) :
    00108         type_(t),
    00109         null_(n)
    00110         {
    00111         }
    00112
    00118         explicit ColData_Tmpl(const char* str,
    00119                         mysql_type_info t = mysql_type_info::string_type,
    00120                         bool n = false) :
    00121         Str(str),
    00122         type_(t),
    00123         buf_(str),
    00124         null_(n)
    00125         {
    00126         }
    00127
    00129         mysql_type_info type() const
    00130         {
    00131                 return type_;
    00132         }
    00133
    00136         bool quote_q() const
    00137         {
    00138                 return type_.quote_q();
    00139         }
    00140
    00143         bool escape_q() const
    00144         {
    00145                 return type_.escape_q();
    00146         }
    00147
    00149         template <class Type> Type conv(Type dummy) const;
    00150
    00152         void it_is_null() { null_ = true; }
    00153
    00155         inline const bool is_null() const { return null_; }
    00156
    00158         inline const std::string& get_string() const
    00159         {
    00160                 return buf_;
    00161         }
    00162
    00165         operator cchar*() const { return buf_.c_str(); }
    00166
    00168         operator signed char() const
    00169                         { return conv(static_cast<signed char>(0)); }
    00170
    00172         operator unsigned char() const
    00173                         { return conv(static_cast<unsigned char>(0)); }
    00174
    00176         operator int() const
    00177                         { return conv(static_cast<int>(0)); }
    00178
    00180         operator unsigned int() const
    00181                         { return conv(static_cast<unsigned int>(0)); }
    00182
    00184         operator short int() const
    00185                         { return conv(static_cast<short int>(0)); }
    00186
    00189         operator unsigned short int() const
    00190                         { return conv(static_cast<unsigned short int>(0)); }
    00191
    00193         operator long int() const
    00194                         { return conv(static_cast<long int>(0)); }
    00195
    00198         operator unsigned long int() const
    00199                         { return conv(static_cast<unsigned long int>(0)); }
    00200
    00201 #if !defined(NO_LONG_LONGS)
    00204         operator longlong() const
    00205                         { return conv(static_cast<longlong>(0)); }
    00206
    00209         operator ulonglong() const
    00210                         { return conv(static_cast<ulonglong>(0)); }
    00211 #endif
    00212
    00214         operator float() const
    00215                         { return conv(static_cast<float>(0)); }
    00216
    00218         operator double() const
    00219                         { return conv(static_cast<double>(0)); }
    00220
    00222         operator bool() const { return conv(0); }
    00223
    00224         template <class T, class B> operator Null<T, B>() const;
    00225
    00226 private:
    00227         mysql_type_info type_;
    00228         std::string buf_;
    00229         bool null_;
    00230 };
    00231
    00234 typedef ColData_Tmpl<const_string> ColData;
    00235
    00238 typedef ColData_Tmpl<std::string> MutableColData;
    00239
    00240
    00241 #if !defined(NO_BINARY_OPERS) && !defined(DOXYGEN_IGNORE)
    00242 // Ignore this section is NO_BINARY_OPERS is defined, or if this section
    00243 // is being parsed by Doxygen.  In the latter case, it's ignored because
    00244 // Doxygen doesn't understand it correctly, and we can't be bothered to
    00245 // explain it to Doxygen.
    00246
    00247 #define oprsw(opr, other, conv) \
    00248   template<class Str> \
    00249   inline other operator opr (ColData_Tmpl<Str> x, other y) \
    00250     {return static_cast<conv>(x) opr y;} \
    00251   template<class Str> \
    00252   inline other operator opr (other x, ColData_Tmpl<Str> y) \
    00253     {return x opr static_cast<conv>(y);}
    00254
    00255 #define operator_binary(other, conv) \
    00256   oprsw(+, other, conv) \
    00257   oprsw(-, other, conv) \
    00258   oprsw(*, other, conv) \
    00259   oprsw(/, other, conv)
    00260
    00261 #define operator_binary_int(other, conv) \
    00262   operator_binary(other, conv) \
    00263   oprsw(%, other, conv) \
    00264   oprsw(&, other, conv) \
    00265   oprsw(^, other, conv) \
    00266   oprsw(|, other, conv) \
    00267   oprsw(<<, other, conv) \
    00268   oprsw(>>, other, conv)
    00269
    00270 operator_binary(float, double)
    00271 operator_binary(double, double)
    00272
    00273 operator_binary_int(char, long int)
    00274 operator_binary_int(int, long int)
    00275 operator_binary_int(short int, long int)
    00276 operator_binary_int(long int, long int)
    00277
    00278 operator_binary_int(unsigned char, unsigned long int)
    00279 operator_binary_int(unsigned int, unsigned long int)
    00280 operator_binary_int(unsigned short int, unsigned long int)
    00281 operator_binary_int(unsigned long int, unsigned long int)
    00282
    00283 #if !defined(NO_LONG_LONGS)
    00284 operator_binary_int(longlong, longlong)
    00285 operator_binary_int(ulonglong, ulonglong)
    00286 #endif
    00287 #endif // NO_BINARY_OPERS
    00288
    00290
    00296 template <class Str> template<class T, class B>
    00297 ColData_Tmpl<Str>::operator Null<T, B>() const
    00298 {
    00299         if ((*this)[0] == 'N' && (*this)[1] == 'U' && (*this)[2] == 'L' &&
    00300                         (*this)[3] == 'L' && Str::size() == 4) {
    00301                 return Null<T, B>(null);
    00302         }
    00303         else {
    00304                 return Null<T, B>(conv(T()));
    00305         }
    00306 }
    00307
    00308 template <class Str> template <class Type>
    00309 Type ColData_Tmpl<Str>::conv(Type /* dummy */) const
    00310 {
    00311         std::string strbuf = buf_;
    00312         strip_all_blanks(strbuf);
    00313         size_t len = strbuf.size();
    00314         const char* str = strbuf.c_str();
    00315         const char* end = str;
    00316         Type num = mysql_convert<Type>(str, end);
    00317
    00318         if (*end == '.') {
    00319                 ++end;
    00320                 for (; *end == '0'; ++end) ;
    00321         }
    00322
    00323         if (*end != '\0' && end != 0) {
    00324                 throw BadConversion(typeid(Type).name(), Str::c_str(),
    00325                                 end - str, len);
    00326         }
    00327
    00328         return num;
    00329 }
    00330
    00331 } // end namespace mysqlpp
    00332
    00333 #endif