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

row.h

Go to the documentation of this file.
00001 
00002 
00003 
00004 /***********************************************************************
00005  Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
00006  MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
00007  Others may also hold copyrights on code in this file.  See the CREDITS
00008  file in the top directory of the distribution for details.
00009 
00010  This file is part of MySQL++.
00011 
00012  MySQL++ is free software; you can redistribute it and/or modify it
00013  under the terms of the GNU Lesser General Public License as published
00014  by the Free Software Foundation; either version 2.1 of the License, or
00015  (at your option) any later version.
00016 
00017  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
00018  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00019  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
00020  License for more details.
00021 
00022  You should have received a copy of the GNU Lesser General Public
00023  License along with MySQL++; if not, write to the Free Software
00024  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
00025  USA
00026 ***********************************************************************/
00027 
00028 #ifndef MYSQLPP_ROW_H
00029 #define MYSQLPP_ROW_H
00030 
00031 #include "coldata.h"
00032 #include "exceptions.h"
00033 #include "resiter.h"
00034 #include "vallist.h"
00035 
00036 #include <vector>
00037 #include <string>
00038 
00039 #include <string.h>
00040 
00041 namespace mysqlpp {
00042 
00043 class FieldNames;
00044 class ResUse;
00045 
00047 
00048 template <class ThisType, class Res>
00049 class RowTemplate
00050 {
00051 protected:
00055         virtual ThisType& self() = 0;
00056 
00059         virtual const ThisType& self() const = 0;
00060 
00061 public:
00063         virtual ~RowTemplate() { }
00064 
00069         virtual const Res& parent() const = 0;
00070 
00075         value_list_ba<ThisType, quote_type0> value_list(
00076                         const char* d = ",") const
00077         {
00078                 return value_list_ba<ThisType, quote_type0>(self(), d, quote);
00079         }
00080         
00085         template <class Manip>
00086         value_list_ba<ThisType, Manip> value_list(const char *d,
00087                         Manip m) const {
00088                 return value_list_ba<ThisType, Manip>(self(), d, m);
00089         }
00090         
00097         template <class Manip>
00098         value_list_b<ThisType, Manip> value_list(const char *d, Manip m,
00099                         const std::vector<bool>& vb) const
00100         {
00101                 return value_list_b<ThisType, Manip>(self(), vb, d, m);
00102         }
00103         
00112         value_list_b<ThisType, quote_type0>
00113         value_list(const char* d, const std::vector<bool>& vb) const
00114         {
00115                 return value_list_b<ThisType, quote_type0>(self(), vb, d, quote);
00116         }
00117         
00125         value_list_b<ThisType, quote_type0> value_list(
00126                         const std::vector<bool> &vb) const
00127         {
00128                 return value_list_b<ThisType, quote_type0>(self(), vb, ",", quote);
00129         }
00130         
00137         template <class Manip>
00138         value_list_b<ThisType, Manip> value_list(const char *d, Manip m,
00139                         bool t0, bool t1 = false, bool t2 = false, bool t3 = false,
00140                         bool t4 = false, bool t5 = false, bool t6 = false,
00141                         bool t7 = false, bool t8 = false, bool t9 = false,
00142                         bool ta = false, bool tb = false, bool tc = false) const
00143         {
00144                 std::vector<bool> vb;
00145                 create_vector(self().size(), vb, t0, t1, t2, t3, t4, t5, t6,
00146                                 t7, t8, t9, ta, tb, tc);
00147                 return value_list_b<ThisType, Manip>(self(), vb, d, m);
00148         }
00149         
00156         value_list_b <ThisType, quote_type0>
00157         value_list(const char *d, bool t0, bool t1 = false, bool t2 = false,
00158                         bool t3 = false, bool t4 = false, bool t5 = false,
00159                         bool t6 = false, bool t7 = false, bool t8 = false,
00160                         bool t9 = false, bool ta = false, bool tb = false,
00161                         bool tc = false) const
00162         {
00163                 std::vector<bool> vb;
00164                 create_vector(self().size(), vb, t0, t1, t2, t3, t4, t5, t6,
00165                                 t7, t8, t9, ta, tb, tc);
00166                 return value_list_b<ThisType, quote_type0>(self(), vb, d, quote);
00167         }
00168         
00175         value_list_b<ThisType, quote_type0> value_list(bool t0,
00176                         bool t1 = false, bool t2 = false, bool t3 = false,
00177                         bool t4 = false, bool t5 = false, bool t6 = false,
00178                         bool t7 = false, bool t8 = false, bool t9 = false,
00179                         bool ta = false, bool tb = false, bool tc = false) const
00180         {
00181                 std::vector<bool> vb;
00182                 create_vector(self().size(), vb, t0, t1, t2, t3, t4, t5, t6,
00183                                 t7, t8, t9, ta, tb, tc);
00184                 return value_list_b<ThisType, quote_type0>(self(), vb, ",", quote);
00185         }
00186         
00193         template <class Manip>
00194         value_list_b<ThisType, Manip> value_list(const char *d, Manip m,
00195                         std::string s0, std::string s1 = "", std::string s2 = "",
00196                         std::string s3 = "", std::string s4 = "",
00197                         std::string s5 = "", std::string s6 = "",
00198                         std::string s7 = "", std::string s8 = "",
00199                         std::string s9 = "", std::string sa = "",
00200                         std::string sb = "", std::string sc = "") const
00201         {
00202                 std::vector<bool> vb;
00203                 create_vector(self(), vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
00204                                 s9, sa, sb, sc);
00205                 return value_list_b<ThisType, Manip>(self(), vb, d, m);
00206         }
00207         
00214         value_list_b<ThisType, quote_type0> value_list(const char *d,
00215                         std::string s0, std::string s1 = "", std::string s2 = "",
00216                         std::string s3 = "", std::string s4 = "",
00217                         std::string s5 = "", std::string s6 = "",
00218                         std::string s7 = "", std::string s8 = "",
00219                         std::string s9 = "", std::string sa = "",
00220                         std::string sb = "", std::string sc = "") const
00221         {
00222                 std::vector<bool> vb;
00223                 create_vector(self(), vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
00224                                 s9, sa, sb, sc);
00225                 return value_list_b<ThisType, quote_type0>(self(), vb, d, quote);
00226         }
00227         
00234         value_list_b<ThisType, quote_type0> value_list(std::string s0,
00235                         std::string s1 = "", std::string s2 = "",
00236                         std::string s3 = "", std::string s4 = "",
00237                         std::string s5 = "", std::string s6 = "",
00238                         std::string s7 = "", std::string s8 = "",
00239                         std::string s9 = "", std::string sa = "",
00240                         std::string sb = "", std::string sc = "") const
00241         {
00242                 std::vector<bool> vb;
00243                 create_vector(self(), vb, s0, s1, s2, s3, s4, s5, s6, s7, s8,
00244                                 s9, sa, sb, sc);
00245                 return value_list_b<ThisType, quote_type0>(self(), vb, ",", quote);
00246         }
00247 
00252         value_list_ba<FieldNames, do_nothing_type0> field_list(
00253                         const char* d = ",") const
00254         {
00255                 return value_list_ba<FieldNames, do_nothing_type0>
00256                                 (parent().names(), d, do_nothing);
00257         }
00258         
00265         template <class Manip>
00266         value_list_ba<FieldNames, Manip> field_list(const char *d,
00267                         Manip m) const
00268         {
00269                 return value_list_ba<FieldNames, Manip>(parent().names(), d, m);
00270         }
00271         
00280         template <class Manip>
00281         value_list_b<FieldNames, Manip> field_list(const char *d, Manip m,
00282                         const std::vector<bool>& vb) const
00283         {
00284                 return value_list_b<FieldNames, Manip>(parent().names(), vb, d, m);
00285         }
00286         
00296         value_list_b<FieldNames, quote_type0> field_list(const char *d,
00297                         const std::vector<bool> &vb) const
00298         {
00299                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00300                                 vb, d, quote);
00301         }
00302         
00310         value_list_b<FieldNames, quote_type0> field_list(
00311                         const std::vector<bool> &vb) const
00312         {
00313                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00314                                 vb, ",", quote);
00315         }
00316         
00324         template <class Manip> value_list_b<FieldNames, Manip> field_list(
00325                         const char *d, Manip m, bool t0, bool t1 = false,
00326                         bool t2 = false, bool t3 = false, bool t4 = false,
00327                         bool t5 = false, bool t6 = false, bool t7 = false,
00328                         bool t8 = false, bool t9 = false, bool ta = false,
00329                         bool tb = false, bool tc = false) const
00330         {
00331                 std::vector<bool> vb;
00332                 create_vector(parent().names().size(), vb, t0, t1, t2, t3, t4,
00333                                 t5, t6, t7, t8, t9, ta, tb, tc);
00334                 return value_list_b<FieldNames, Manip>(parent().names(), vb, d, m);
00335         }
00336         
00344         value_list_b<FieldNames, quote_type0> field_list(const char *d,
00345                         bool t0, bool t1 = false, bool t2 = false, bool t3 = false,
00346                         bool t4 = false, bool t5 = false, bool t6 = false,
00347                         bool t7 = false, bool t8 = false, bool t9 = false,
00348                         bool ta = false, bool tb = false, bool tc = false) const
00349         {
00350                 std::vector<bool> vb;
00351                 create_vector(parent().names().size(), vb, t0, t1, t2, t3, t4,
00352                                 t5, t6, t7, t8, t9, ta, tb, tc);
00353                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00354                                 vb, d, quote);
00355         }
00356         
00363         value_list_b<FieldNames, quote_type0> field_list(bool t0,
00364                         bool t1 = false, bool t2 = false, bool t3 = false,
00365                         bool t4 = false, bool t5 = false, bool t6 = false,
00366                         bool t7 = false, bool t8 = false, bool t9 = false,
00367                         bool ta = false, bool tb = false, bool tc = false) const
00368         {
00369                 std::vector<bool> vb;
00370                 create_vector(parent().names().size(), vb, t0, t1, t2, t3, t4,
00371                                 t5, t6, t7, t8, t9, ta, tb, tc);
00372                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00373                                 vb, ",", quote);
00374         }
00375         
00382         template <class Manip> value_list_b<FieldNames, Manip> field_list(
00383                         const char *d, Manip m, std::string s0, std::string s1 = "",
00384                         std::string s2 = "", std::string s3 = "",
00385                         std::string s4 = "", std::string s5 = "",
00386                         std::string s6 = "", std::string s7 = "",
00387                         std::string s8 = "", std::string s9 = "",
00388                         std::string sa = "", std::string sb = "",
00389                         std::string sc = "") const
00390         {
00391                 std::vector<bool> vb;
00392                 create_vector(parent().names(), vb, s0, s1, s2, s3, s4, s5, s6,
00393                                 s7, s8, s9, sa, sb, sc);
00394                 return value_list_b<FieldNames, Manip>(parent().names(), vb, d, m);
00395         }
00396         
00403         value_list_b<FieldNames, quote_type0> field_list(const char *d,
00404                         std::string s0, std::string s1 = "", std::string s2 = "",
00405                         std::string s3 = "", std::string s4 = "",
00406                         std::string s5 = "", std::string s6 = "",
00407                         std::string s7 = "", std::string s8 = "",
00408                         std::string s9 = "", std::string sa = "",
00409                         std::string sb = "", std::string sc = "") const
00410         {
00411                 std::vector<bool> vb;
00412                 create_vector(parent().names(), vb, s0, s1, s2, s3, s4, s5, s6,
00413                                 s7, s8, s9, sa, sb, sc);
00414                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00415                                 vb, d, quote);
00416         }
00417         
00424         value_list_b<FieldNames, quote_type0> field_list(std::string s0,
00425                         std::string s1 = "", std::string s2 = "",
00426                         std::string s3 = "", std::string s4 = "",
00427                         std::string s5 = "", std::string s6 = "",
00428                         std::string s7 = "", std::string s8 = "",
00429                         std::string s9 = "", std::string sa = "",
00430                         std::string sb = "", std::string sc = "") const
00431         {
00432                 std::vector<bool> vb;
00433                 create_vector(parent().names(), vb, s0, s1, s2, s3, s4, s5, s6,
00434                                 s7, s8, s9, sa, sb, sc);
00435                 return value_list_b<FieldNames, quote_type0>(parent().names(),
00436                                 vb, ",", quote);
00437         }
00438 
00444         equal_list_ba<FieldNames, ThisType, quote_type0> equal_list(
00445                         const char* d = ",", const char* e = " = ") const
00446         {
00447                 return equal_list_ba<FieldNames, ThisType, quote_type0>(
00448                                 parent().names(), self(), d, e, quote);
00449         }
00450         
00471         template <class Manip>
00472         equal_list_ba<FieldNames, ThisType, Manip> equal_list(const char* d,
00473                         const char* e, Manip m) const 
00474         {
00475                 return equal_list_ba<FieldNames, ThisType, Manip>(
00476                                 parent().names(), self(), d, e, m);
00477         }
00478 };
00479 
00480 
00482 class Row : public const_subscript_container<Row, ColData,
00483                 const ColData>, public RowTemplate<Row, ResUse>
00484 {
00485 private:
00486         std::vector<std::string> data;
00487         std::vector<bool> is_nulls;
00488         const ResUse* res;
00489         bool throw_exceptions;
00490         bool initialized;
00491 
00492 public:
00494         Row() { }
00495         
00502         Row(MYSQL_ROW d, const ResUse* r, unsigned long* jj, bool te = false) :
00503         res(r),
00504         throw_exceptions(te),
00505         initialized(false)
00506         {
00507                 if (!d || !r) {
00508                         if (throw_exceptions) {
00509                                 throw BadQuery("ROW or RES is NULL");
00510                         }
00511                         else {
00512                                 return;
00513                         }
00514                 }
00515                 data.clear();
00516                 is_nulls.clear();
00517                 initialized = true;
00518                 for (unsigned int i = 0; i < size(); i++) {
00519                         data.insert(data.end(),
00520                                         (d[i] ?  std::string(d[i], jj[i]) : std::string("NULL")));
00521                         is_nulls.insert(is_nulls.end(), d[i] ? false : true);
00522                 }
00523         }
00524 
00526         ~Row()
00527         {
00528                 data.clear();
00529                 is_nulls.clear();
00530                 initialized = false;
00531         }
00532 
00534         const Row & self() const
00535         {
00536                 return *this;
00537         }
00538 
00540         Row& self()
00541         {
00542                 return *this;
00543         }
00544 
00546         const ResUse& parent() const
00547         {
00548                 return *res;
00549         }
00550 
00552         size_type size() const;
00553 
00584         const ColData operator [](size_type i) const;
00585 
00591         const ColData lookup_by_name(const char*) const;
00592 
00598         const char* raw_data(int i) const
00599         {
00600                 return data[i].data();
00601         }
00602 
00604         operator bool() const
00605         {
00606                 return data.size();
00607         }
00608 };
00609 
00610 } // end namespace mysqlpp
00611 
00612 #endif

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