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

type_info.h

Go to the documentation of this file.
00001 
00002 
00003 
00004 
00005 
00006 
00007 /***********************************************************************
00008  Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
00009  MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
00010  Others may also hold copyrights on code in this file.  See the CREDITS
00011  file in the top directory of the distribution for details.
00012 
00013  This file is part of MySQL++.
00014 
00015  MySQL++ is free software; you can redistribute it and/or modify it
00016  under the terms of the GNU Lesser General Public License as published
00017  by the Free Software Foundation; either version 2.1 of the License, or
00018  (at your option) any later version.
00019 
00020  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
00021  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00022  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
00023  License for more details.
00024 
00025  You should have received a copy of the GNU Lesser General Public
00026  License along with MySQL++; if not, write to the Free Software
00027  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
00028  USA
00029 ***********************************************************************/
00030 
00031 #ifndef MYSQLPP_TYPE_INFO_H
00032 #define MYSQLPP_TYPE_INFO_H
00033 
00034 #include "defs.h"
00035 
00036 #include <mysql.h>
00037 
00038 #include <typeinfo>
00039 #include <map>
00040 
00041 namespace mysqlpp {
00042 
00043 class mysql_type_info;
00044 class mysql_ti_sql_type_info_lookup;
00045 
00046 #if !defined(DOXYGEN_IGNORE)
00047 // Doxygen will not generate documentation for this section.
00048 
00049 class mysql_ti_sql_type_info
00050 {
00051         friend class mysql_type_info;
00052         friend class mysql_ti_sql_type_info_lookup;
00053 
00054 private:
00055         const char* _sql_name;
00056         const std::type_info* _c_type;
00057         const unsigned char _base_type;
00058         const bool _default;
00059         
00060         mysql_ti_sql_type_info& operator=(const mysql_ti_sql_type_info& b);
00061         
00062         // Not initting _base_type and _default because only mysql_type_info
00063         // can create them.  There *must* be only one copy of each.
00064         mysql_ti_sql_type_info() :
00065         _base_type(0),
00066         _default(false) 
00067         {
00068         }
00069         
00070         mysql_ti_sql_type_info(const char* s, const std::type_info& t,
00071                         const unsigned char bt = 0, const bool d = false) :
00072         _sql_name(s),
00073         _c_type(&t),
00074         _base_type(bt),
00075         _default(d)
00076         {
00077         }
00078 };
00079 
00080 
00081 struct type_info_cmp
00082 {
00083         bool operator() (const std::type_info* lhs,
00084                         const std::type_info* rhs) const
00085         {
00086                 return lhs->before(*rhs) != 0;
00087         }
00088 };
00089 
00090 class mysql_ti_sql_type_info_lookup
00091 {
00092         friend class mysql_type_info;
00093 
00094 private:
00095         typedef mysql_ti_sql_type_info sql_type_info;
00096 
00097         std::map<const std::type_info*, unsigned char, type_info_cmp> _map;
00098 
00099         mysql_ti_sql_type_info_lookup(const sql_type_info types[],
00100                         const int size);
00101 
00102         const unsigned char& operator [](const std::type_info& ti) const
00103         {
00104                 return _map.find(&ti)->second;
00105         }
00106 };
00107 
00108 #endif // !defined(DOXYGEN_IGNORE)
00109 
00110 
00114 class mysql_type_info
00115 {
00116 private:
00117         typedef mysql_ti_sql_type_info sql_type_info;
00118         typedef mysql_ti_sql_type_info_lookup sql_type_info_lookup;
00119 
00120         static const sql_type_info types[62];
00121 
00122         static const unsigned char offset = 0;
00123         static const unsigned char unsigned_offset = 21;
00124         static const unsigned char null_offset = 31;
00125         static const unsigned char unsigned_null_offset = 52;
00126 
00127         static const sql_type_info_lookup lookups;
00128 
00144         static unsigned char type(enum_field_types t, bool _unsigned,
00145                         bool _null = false);
00146 
00147 public:
00152         static const unsigned char string_type = 20;
00153 
00154         unsigned int _length;           
00155         unsigned int _max_length;       
00156 
00157 private:
00158         unsigned char num;
00159         inline const sql_type_info& deref() const;
00160 
00161 public:
00163         mysql_type_info()
00164         {
00165         }
00166         
00173         mysql_type_info(unsigned char n) :
00174         num(n)
00175         {
00176         }
00177 
00183         inline mysql_type_info(enum_field_types t, bool _unsigned, bool _null);
00184 
00188         inline mysql_type_info(const MYSQL_FIELD& f);
00189 
00191         mysql_type_info(const mysql_type_info& t) :
00192         num(t.num)
00193         {
00194         }
00195 
00200         mysql_type_info(const std::type_info& t)
00201         {
00202                 num = lookups[t];
00203         }
00204 
00210         mysql_type_info& operator =(unsigned char n)
00211         {
00212                 num = n;
00213                 return *this;
00214         }
00215 
00217         mysql_type_info& operator =(const mysql_type_info& t)
00218         {
00219                 num = t.num;
00220                 return *this;
00221         }
00222 
00227         mysql_type_info& operator =(const std::type_info& t)
00228         {
00229                 num = lookups[t];
00230                 return *this;
00231         }
00232 
00237         inline const char* name() const;
00238 
00242         inline const char* sql_name() const;
00243 
00248         inline const std::type_info& c_type() const;
00249 
00254         inline const unsigned int length() const;
00255 
00260         inline const unsigned int max_length() const;
00261 
00267         inline const mysql_type_info base_type() const;
00268 
00274         int id() const
00275         {
00276                 return num;
00277         }
00278         
00284         bool quote_q() const;
00285 
00291         bool escape_q() const;
00292 
00297         bool before(mysql_type_info& b)
00298         {
00299                 return num < b.num;
00300         }
00301 };
00302 
00303 inline const mysql_type_info::sql_type_info& mysql_type_info::deref() const
00304 {
00305         return types[num];
00306 }
00307 
00308 inline const char* mysql_type_info::name() const 
00309 {
00310         return deref()._c_type->name();
00311 }
00312 
00313 inline const char* mysql_type_info::sql_name() const
00314 {
00315         return deref()._sql_name;
00316 }
00317 
00318 inline const unsigned int mysql_type_info::length() const
00319 {
00320         return _length;
00321 }
00322 
00323 inline const unsigned int mysql_type_info::max_length() const
00324 {
00325         return _max_length;
00326 }
00327 
00328 inline const std::type_info& mysql_type_info::c_type() const
00329 {
00330         return *deref()._c_type;
00331 }
00332 
00333 inline const mysql_type_info mysql_type_info::base_type() const
00334 {
00335         return mysql_type_info(deref()._base_type);
00336 }
00337 
00338 inline mysql_type_info::mysql_type_info(enum_field_types t,
00339                 bool _unsigned, bool _null)
00340 {
00341         num = type(t, _unsigned, _null);
00342 }
00343 
00344 inline mysql_type_info::mysql_type_info(const MYSQL_FIELD& f)
00345 {
00346         num = type(f.type, (f.flags & UNSIGNED_FLAG) != 0,
00347                         (f.flags & NOT_NULL_FLAG) == 0);
00348         _length = f.length;
00349         _max_length = f.max_length;
00350 }
00351 
00353 inline bool operator ==(const mysql_type_info& a, const mysql_type_info& b)
00354 {
00355         return a.id() == b.id();
00356 }
00357 
00359 inline bool operator !=(const mysql_type_info& a, const mysql_type_info& b)
00360 {
00361         return a.id() != b.id();
00362 }
00363 
00366 inline bool operator ==(const std::type_info& a, const mysql_type_info& b)
00367 {
00368         return a == b.c_type();
00369 }
00370 
00373 inline bool operator !=(const std::type_info& a, const mysql_type_info& b)
00374 {
00375         return a != b.c_type();
00376 }
00377 
00380 inline bool operator ==(const mysql_type_info& a, const std::type_info& b)
00381 {
00382         return a.c_type() == b;
00383 }
00384 
00387 inline bool operator !=(const mysql_type_info& a, const std::type_info& b)
00388 {
00389         return a.c_type() != b;
00390 }
00391 
00392 }                                                               // end namespace mysqlpp
00393 
00394 #endif
00395 

Generated on Thu May 26 09:39:58 2005 for MySQL++ by doxygen1.2.18