Logo
~Sockets~
~Examples~
~Contact~

libfuture.cpp

Go to the documentation of this file.
00001 /*
00002  *       /usr/devel/src/libfuture/libfuture.cpp
00003  *       Generated by sql2class v1.9.3 by (C) AH 2000-2006
00004  *        using command line
00005  *        $ sql2class -build -lib libfuture -sqlite str-future -namespace db -overwrite -getset
00006  *       Date: Fri Nov 10 17:16:37 2006
00007  */
00008 
00009 /*
00010 Copyright (C) 2001-2006  Anders Hedstrom (grymse@alhem.net)
00011 
00012 This program is free software; you can redistribute it and/or
00013 modify it under the terms of the GNU General Public License
00014 as published by the Free Software Foundation; either version 2
00015 of the License, or (at your option) any later version.
00016 
00017 This program is distributed in the hope that it will be useful,
00018 but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 GNU General Public License for more details.
00021 
00022 You should have received a copy of the GNU General Public License
00023 along with this program; if not, write to the Free Software
00024 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00025 */
00026 #include <libfuture.h>
00027 
00028 namespace db {
00029 
00034 Account::Account(Database *db)
00035 {
00036         database = db;
00037         new_object = 1;
00038         clear();
00039 }
00040 
00041 
00042 Account::Account(Database *db,const std::string& sql)
00043 {
00044         database = db;
00045         new_object = 1;
00046         spawn(sql);
00047 }
00048 
00049 
00050 Account::Account(Database *db,Query *qd,int offset)
00051 {
00052         database = db;
00053         new_object = 0;
00054         spawn(qd, offset);
00055 }
00056 
00057 
00058 Account::Account(Database& db,long i_num):database(&db),new_object(1)
00059 {
00060         Query q(*database);
00061         std::string sql = "select * from account where ";
00062         {
00063                 char slask[100];
00064                 sprintf(slask,"num='%ld'",i_num);
00065                 sql += slask;
00066         }
00067         spawn(sql);
00068 }
00069 
00070 
00071 Account::Account(Database& db,const std::string&  i_name):database(&db),new_object(1)
00072 {
00073         Query q(*database);
00074         std::string sql = "select * from account where ";
00075         sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
00076         spawn(sql);
00077 }
00078 
00079 
00080 Account::~Account()
00081 {
00082 }
00083 
00084 
00085 void Account::select(const std::string& sql)
00086 {
00087         spawn(sql);
00088 }
00089 
00090 
00091 unsigned long long int Account::insert()
00092 {
00093         Query q(*database);
00094         std::string sql;
00095 
00096         sql = "insert into account(name,passwd,display_name,wizard,email,area,chunk,chunkx,chunky,facing,wizview,race)";
00097         sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
00098         sql += ", '" + q.GetDatabase().safestr(this -> passwd) + "'";
00099         sql += ", '" + q.GetDatabase().safestr(this -> display_name) + "'";
00100         {
00101                 char slask[100];
00102                 sprintf(slask,", %d",this -> wizard);
00103                 sql += slask;
00104         }
00105         sql += ", '" + q.GetDatabase().safestr(this -> email) + "'";
00106         {
00107                 char slask[100];
00108                 sprintf(slask,", %ld",this -> area);
00109                 sql += slask;
00110         }
00111         {
00112                 char slask[100];
00113                 sprintf(slask,", %ld",this -> chunk);
00114                 sql += slask;
00115         }
00116         {
00117                 char slask[100];
00118                 sprintf(slask,", %ld",this -> chunkx);
00119                 sql += slask;
00120         }
00121         {
00122                 char slask[100];
00123                 sprintf(slask,", %ld",this -> chunky);
00124                 sql += slask;
00125         }
00126         {
00127                 char slask[100];
00128                 sprintf(slask,", %ld",this -> facing);
00129                 sql += slask;
00130         }
00131         {
00132                 char slask[100];
00133                 sprintf(slask,", %ld",this -> wizview);
00134                 sql += slask;
00135         }
00136         {
00137                 char slask[100];
00138                 sprintf(slask,", %ld",this -> race);
00139                 sql += slask;
00140         }
00141         sql += ")";
00142         q.execute(sql);
00143         new_object = 0;
00144         unsigned long long int inserted_id = q.insert_id();
00145         num = inserted_id;
00146         return inserted_id;
00147 }
00148 
00149 
00150 void Account::update()
00151 {
00152         update(this -> num);
00153 }
00154 
00155 
00156 void Account::update(long i_num)
00157 {
00158         Query q(*database);
00159         std::string sql;
00160         sql += "update account set name='" + q.GetDatabase().safestr(this -> name) + "'";
00161         sql += ", passwd='" + q.GetDatabase().safestr(this -> passwd) + "'";
00162         sql += ", display_name='" + q.GetDatabase().safestr(this -> display_name) + "'";
00163         {
00164                 char slask[200];
00165                 sprintf(slask,", wizard=%d",this -> wizard);
00166                 sql += slask;
00167         }
00168         sql += ", email='" + q.GetDatabase().safestr(this -> email) + "'";
00169         {
00170                 char slask[200];
00171                 sprintf(slask,", area=%ld",this -> area);
00172                 sql += slask;
00173         }
00174         {
00175                 char slask[200];
00176                 sprintf(slask,", chunk=%ld",this -> chunk);
00177                 sql += slask;
00178         }
00179         {
00180                 char slask[200];
00181                 sprintf(slask,", chunkx=%ld",this -> chunkx);
00182                 sql += slask;
00183         }
00184         {
00185                 char slask[200];
00186                 sprintf(slask,", chunky=%ld",this -> chunky);
00187                 sql += slask;
00188         }
00189         {
00190                 char slask[200];
00191                 sprintf(slask,", facing=%ld",this -> facing);
00192                 sql += slask;
00193         }
00194         {
00195                 char slask[200];
00196                 sprintf(slask,", wizview=%ld",this -> wizview);
00197                 sql += slask;
00198         }
00199         {
00200                 char slask[200];
00201                 sprintf(slask,", race=%ld",this -> race);
00202                 sql += slask;
00203         }
00204         {
00205                 char slask[200];
00206                 sprintf(slask," where num='%ld'",i_num);
00207                 sql += slask;
00208         }
00209         q.execute(sql);
00210 }
00211 
00212 
00213 void Account::save()
00214 {
00215         if (new_object)
00216                 insert();
00217         else
00218                 update();
00219 }
00220 
00221 
00222 void Account::erase()
00223 {
00224         if (!new_object)
00225         {
00226                 std::string sql = "delete from account where";
00227                 Query q(*database);
00228                 {
00229                         char slask[200];
00230                         sprintf(slask," num='%ld'",this -> num);
00231                         sql += slask;
00232                 }
00233                 q.execute(sql);
00234         }
00235 }
00236 
00237 
00238 std::string Account::xml()
00239 {
00240         Query q(*database);
00241         std::string dest;
00242         char slask[200];
00243         dest = "<ACCOUNT>";
00244         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00245         dest += slask;
00246         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00247         dest += "<PASSWD>" + q.GetDatabase().xmlsafestr(this -> passwd) + "</PASSWD>";
00248         dest += "<DISPLAY_NAME>" + q.GetDatabase().xmlsafestr(this -> display_name) + "</DISPLAY_NAME>";
00249         sprintf(slask,"<WIZARD>%d</WIZARD>",this -> wizard);
00250         dest += slask;
00251         dest += "<EMAIL>" + q.GetDatabase().xmlsafestr(this -> email) + "</EMAIL>";
00252         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
00253         dest += slask;
00254         sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
00255         dest += slask;
00256         sprintf(slask,"<CHUNKX>%ld</CHUNKX>",this -> chunkx);
00257         dest += slask;
00258         sprintf(slask,"<CHUNKY>%ld</CHUNKY>",this -> chunky);
00259         dest += slask;
00260         sprintf(slask,"<FACING>%ld</FACING>",this -> facing);
00261         dest += slask;
00262         sprintf(slask,"<WIZVIEW>%ld</WIZVIEW>",this -> wizview);
00263         dest += slask;
00264         sprintf(slask,"<RACE>%ld</RACE>",this -> race);
00265         dest += slask;
00266         dest += "</ACCOUNT>";
00267         return dest;
00268 }
00269 
00270 
00271 std::string Account::xml(const std::string& tag,const std::string& xvalx)
00272 {
00273         Query q(*database);
00274         std::string dest;
00275         char slask[200];
00276         dest = "<ACCOUNT " + tag + "=\"" + xvalx + "\">";
00277         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00278         dest += slask;
00279         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00280         dest += "<PASSWD>" + q.GetDatabase().xmlsafestr(this -> passwd) + "</PASSWD>";
00281         dest += "<DISPLAY_NAME>" + q.GetDatabase().xmlsafestr(this -> display_name) + "</DISPLAY_NAME>";
00282         sprintf(slask,"<WIZARD>%d</WIZARD>",this -> wizard);
00283         dest += slask;
00284         dest += "<EMAIL>" + q.GetDatabase().xmlsafestr(this -> email) + "</EMAIL>";
00285         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
00286         dest += slask;
00287         sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
00288         dest += slask;
00289         sprintf(slask,"<CHUNKX>%ld</CHUNKX>",this -> chunkx);
00290         dest += slask;
00291         sprintf(slask,"<CHUNKY>%ld</CHUNKY>",this -> chunky);
00292         dest += slask;
00293         sprintf(slask,"<FACING>%ld</FACING>",this -> facing);
00294         dest += slask;
00295         sprintf(slask,"<WIZVIEW>%ld</WIZVIEW>",this -> wizview);
00296         dest += slask;
00297         sprintf(slask,"<RACE>%ld</RACE>",this -> race);
00298         dest += slask;
00299         dest += "</ACCOUNT>";
00300         return dest;
00301 }
00302 
00303 
00304 size_t Account::num_cols()
00305 {
00306         return 13;
00307 }
00308 
00309 
00310 void Account::clear()
00311 {
00312         this -> num = 0;
00313         this -> name = "";
00314         this -> passwd = "";
00315         this -> display_name = "";
00316         this -> wizard = 0;
00317         this -> email = "";
00318         this -> area = 0;
00319         this -> chunk = 0;
00320         this -> chunkx = 0;
00321         this -> chunky = 0;
00322         this -> facing = 0;
00323         this -> wizview = 0;
00324         this -> race = 0;
00325 }
00326 
00327 
00328 void Account::spawn(const std::string& sql)
00329 {
00330         Query q(*database);
00331         std::string temp;
00332 
00333         clear();
00334 
00335         if (!strncasecmp(sql.c_str(),"select * ",9))
00336         {
00337                 temp = "select num,name,passwd,display_name,wizard,email,area,chunk,chunkx,chunky,facing,wizview,race " + sql.substr(9);
00338         } else
00339                 temp = sql;
00340         q.get_result(temp);
00341         if (q.fetch_row())
00342         {
00343                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
00344                 this -> name = q.getstr(1);                                                                                                                                                             // 1 - name varchar(255)
00345                 this -> passwd = q.getstr(2);                                                                                                                                                           // 2 - passwd varchar(255)
00346                 this -> display_name = q.getstr(3);                                                                                                                                                             // 3 - display_name varchar(255)
00347                 this -> wizard = q.getval(4);                                                                                                                                                           // 4 - wizard tinyint(1)
00348                 this -> email = q.getstr(5);                                                                                                                                                            // 5 - email varchar(255)
00349                 this -> area = q.getval(6);                                                                                                                                                             // 6 - area integer
00350                 this -> chunk = q.getval(7);                                                                                                                                                            // 7 - chunk integer
00351                 this -> chunkx = q.getval(8);                                                                                                                                                           // 8 - chunkx integer
00352                 this -> chunky = q.getval(9);                                                                                                                                                           // 9 - chunky integer
00353                 this -> facing = q.getval(10);                                                                                                                                                          // 10 - facing integer
00354                 this -> wizview = q.getval(11);                                                                                                                                                         // 11 - wizview integer
00355                 this -> race = q.getval(12);                                                                                                                                                            // 12 - race integer
00356                 new_object = 0;
00357         } else
00358                 clear();
00359         q.free_result();
00360 }
00361 
00362 
00363 void Account::spawn(Query *qd,int offset)
00364 {
00365         clear();
00366 
00367         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
00368         this -> name = qd -> getstr(1 + offset);                                                                                                                                                                // 1 - name varchar(255)
00369         this -> passwd = qd -> getstr(2 + offset);                                                                                                                                                              // 2 - passwd varchar(255)
00370         this -> display_name = qd -> getstr(3 + offset);                                                                                                                                                                // 3 - display_name varchar(255)
00371         this -> wizard = qd -> getval(4 + offset);                                                                                                                                                              // 4 - wizard tinyint(1)
00372         this -> email = qd -> getstr(5 + offset);                                                                                                                                                               // 5 - email varchar(255)
00373         this -> area = qd -> getval(6 + offset);                                                                                                                                                                // 6 - area integer
00374         this -> chunk = qd -> getval(7 + offset);                                                                                                                                                               // 7 - chunk integer
00375         this -> chunkx = qd -> getval(8 + offset);                                                                                                                                                              // 8 - chunkx integer
00376         this -> chunky = qd -> getval(9 + offset);                                                                                                                                                              // 9 - chunky integer
00377         this -> facing = qd -> getval(10 + offset);                                                                                                                                                             // 10 - facing integer
00378         this -> wizview = qd -> getval(11 + offset);                                                                                                                                                            // 11 - wizview integer
00379         this -> race = qd -> getval(12 + offset);                                                                                                                                                               // 12 - race integer
00380 }
00381 
00382 
00383 // End of implementation of class 'Account'
00384 
00385 } // End of namespace
00386 namespace db {
00387 
00392 Eventcount::Eventcount(Database *db)
00393 {
00394         database = db;
00395         new_object = 1;
00396         clear();
00397 }
00398 
00399 
00400 Eventcount::Eventcount(Database *db,const std::string& sql)
00401 {
00402         database = db;
00403         new_object = 1;
00404         spawn(sql);
00405 }
00406 
00407 
00408 Eventcount::Eventcount(Database *db,Query *qd,int offset)
00409 {
00410         database = db;
00411         new_object = 0;
00412         spawn(qd, offset);
00413 }
00414 
00415 
00416 Eventcount::Eventcount(Database& db,long i_num):database(&db),new_object(1)
00417 {
00418         Query q(*database);
00419         std::string sql = "select * from eventcount where ";
00420         {
00421                 char slask[100];
00422                 sprintf(slask,"num='%ld'",i_num);
00423                 sql += slask;
00424         }
00425         spawn(sql);
00426 }
00427 
00428 
00429 Eventcount::Eventcount(Database& db,const std::string&  i_event_name):database(&db),new_object(1)
00430 {
00431         Query q(*database);
00432         std::string sql = "select * from eventcount where ";
00433         sql += "event_name='" + q.GetDatabase().safestr(i_event_name) + "'";
00434         spawn(sql);
00435 }
00436 
00437 
00438 Eventcount::~Eventcount()
00439 {
00440 }
00441 
00442 
00443 void Eventcount::select(const std::string& sql)
00444 {
00445         spawn(sql);
00446 }
00447 
00448 
00449 unsigned long long int Eventcount::insert()
00450 {
00451         Query q(*database);
00452         std::string sql;
00453 
00454         sql = "insert into eventcount(event_name,count)";
00455         sql += " values('" + q.GetDatabase().safestr(this -> event_name) + "'";
00456         {
00457                 char slask[100];
00458                 sprintf(slask,", %ld",this -> count);
00459                 sql += slask;
00460         }
00461         sql += ")";
00462         q.execute(sql);
00463         new_object = 0;
00464         unsigned long long int inserted_id = q.insert_id();
00465         num = inserted_id;
00466         return inserted_id;
00467 }
00468 
00469 
00470 void Eventcount::update()
00471 {
00472         update(this -> num);
00473 }
00474 
00475 
00476 void Eventcount::update(long i_num)
00477 {
00478         Query q(*database);
00479         std::string sql;
00480         sql += "update eventcount set event_name='" + q.GetDatabase().safestr(this -> event_name) + "'";
00481         {
00482                 char slask[200];
00483                 sprintf(slask,", count=%ld",this -> count);
00484                 sql += slask;
00485         }
00486         {
00487                 char slask[200];
00488                 sprintf(slask," where num='%ld'",i_num);
00489                 sql += slask;
00490         }
00491         q.execute(sql);
00492 }
00493 
00494 
00495 void Eventcount::save()
00496 {
00497         if (new_object)
00498                 insert();
00499         else
00500                 update();
00501 }
00502 
00503 
00504 void Eventcount::erase()
00505 {
00506         if (!new_object)
00507         {
00508                 std::string sql = "delete from eventcount where";
00509                 Query q(*database);
00510                 {
00511                         char slask[200];
00512                         sprintf(slask," num='%ld'",this -> num);
00513                         sql += slask;
00514                 }
00515                 q.execute(sql);
00516         }
00517 }
00518 
00519 
00520 std::string Eventcount::xml()
00521 {
00522         Query q(*database);
00523         std::string dest;
00524         char slask[200];
00525         dest = "<EVENTCOUNT>";
00526         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00527         dest += slask;
00528         dest += "<EVENT_NAME>" + q.GetDatabase().xmlsafestr(this -> event_name) + "</EVENT_NAME>";
00529         sprintf(slask,"<COUNT>%ld</COUNT>",this -> count);
00530         dest += slask;
00531         dest += "</EVENTCOUNT>";
00532         return dest;
00533 }
00534 
00535 
00536 std::string Eventcount::xml(const std::string& tag,const std::string& xvalx)
00537 {
00538         Query q(*database);
00539         std::string dest;
00540         char slask[200];
00541         dest = "<EVENTCOUNT " + tag + "=\"" + xvalx + "\">";
00542         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00543         dest += slask;
00544         dest += "<EVENT_NAME>" + q.GetDatabase().xmlsafestr(this -> event_name) + "</EVENT_NAME>";
00545         sprintf(slask,"<COUNT>%ld</COUNT>",this -> count);
00546         dest += slask;
00547         dest += "</EVENTCOUNT>";
00548         return dest;
00549 }
00550 
00551 
00552 size_t Eventcount::num_cols()
00553 {
00554         return 3;
00555 }
00556 
00557 
00558 void Eventcount::clear()
00559 {
00560         this -> num = 0;
00561         this -> event_name = "";
00562         this -> count = 0;
00563 }
00564 
00565 
00566 void Eventcount::spawn(const std::string& sql)
00567 {
00568         Query q(*database);
00569         std::string temp;
00570 
00571         clear();
00572 
00573         if (!strncasecmp(sql.c_str(),"select * ",9))
00574         {
00575                 temp = "select num,event_name,count " + sql.substr(9);
00576         } else
00577                 temp = sql;
00578         q.get_result(temp);
00579         if (q.fetch_row())
00580         {
00581                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
00582                 this -> event_name = q.getstr(1);                                                                                                                                                               // 1 - event_name varchar(255)
00583                 this -> count = q.getval(2);                                                                                                                                                            // 2 - count integer
00584                 new_object = 0;
00585         } else
00586                 clear();
00587         q.free_result();
00588 }
00589 
00590 
00591 void Eventcount::spawn(Query *qd,int offset)
00592 {
00593         clear();
00594 
00595         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
00596         this -> event_name = qd -> getstr(1 + offset);                                                                                                                                                          // 1 - event_name varchar(255)
00597         this -> count = qd -> getval(2 + offset);                                                                                                                                                               // 2 - count integer
00598 }
00599 
00600 
00601 // End of implementation of class 'Eventcount'
00602 
00603 } // End of namespace
00604 namespace db {
00605 
00610 Area::Area(Database *db)
00611 {
00612         database = db;
00613         new_object = 1;
00614         clear();
00615 }
00616 
00617 
00618 Area::Area(Database *db,const std::string& sql)
00619 {
00620         database = db;
00621         new_object = 1;
00622         spawn(sql);
00623 }
00624 
00625 
00626 Area::Area(Database *db,Query *qd,int offset)
00627 {
00628         database = db;
00629         new_object = 0;
00630         spawn(qd, offset);
00631 }
00632 
00633 
00634 Area::Area(Database& db,long i_num):database(&db),new_object(1)
00635 {
00636         Query q(*database);
00637         std::string sql = "select * from area where ";
00638         {
00639                 char slask[100];
00640                 sprintf(slask,"num='%ld'",i_num);
00641                 sql += slask;
00642         }
00643         spawn(sql);
00644 }
00645 
00646 
00647 Area::Area(Database& db,const std::string&  i_name):database(&db),new_object(1)
00648 {
00649         Query q(*database);
00650         std::string sql = "select * from area where ";
00651         sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
00652         spawn(sql);
00653 }
00654 
00655 
00656 Area::~Area()
00657 {
00658 }
00659 
00660 
00661 void Area::select(const std::string& sql)
00662 {
00663         spawn(sql);
00664 }
00665 
00666 
00667 unsigned long long int Area::insert()
00668 {
00669         Query q(*database);
00670         std::string sql;
00671 
00672         sql = "insert into area(name,width,height)";
00673         sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
00674         {
00675                 char slask[100];
00676                 sprintf(slask,", %ld",this -> width);
00677                 sql += slask;
00678         }
00679         {
00680                 char slask[100];
00681                 sprintf(slask,", %ld",this -> height);
00682                 sql += slask;
00683         }
00684         sql += ")";
00685         q.execute(sql);
00686         new_object = 0;
00687         unsigned long long int inserted_id = q.insert_id();
00688         num = inserted_id;
00689         return inserted_id;
00690 }
00691 
00692 
00693 void Area::update()
00694 {
00695         update(this -> num);
00696 }
00697 
00698 
00699 void Area::update(long i_num)
00700 {
00701         Query q(*database);
00702         std::string sql;
00703         sql += "update area set name='" + q.GetDatabase().safestr(this -> name) + "'";
00704         {
00705                 char slask[200];
00706                 sprintf(slask,", width=%ld",this -> width);
00707                 sql += slask;
00708         }
00709         {
00710                 char slask[200];
00711                 sprintf(slask,", height=%ld",this -> height);
00712                 sql += slask;
00713         }
00714         {
00715                 char slask[200];
00716                 sprintf(slask," where num='%ld'",i_num);
00717                 sql += slask;
00718         }
00719         q.execute(sql);
00720 }
00721 
00722 
00723 void Area::save()
00724 {
00725         if (new_object)
00726                 insert();
00727         else
00728                 update();
00729 }
00730 
00731 
00732 void Area::erase()
00733 {
00734         if (!new_object)
00735         {
00736                 std::string sql = "delete from area where";
00737                 Query q(*database);
00738                 {
00739                         char slask[200];
00740                         sprintf(slask," num='%ld'",this -> num);
00741                         sql += slask;
00742                 }
00743                 q.execute(sql);
00744         }
00745 }
00746 
00747 
00748 std::string Area::xml()
00749 {
00750         Query q(*database);
00751         std::string dest;
00752         char slask[200];
00753         dest = "<AREA>";
00754         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00755         dest += slask;
00756         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00757         sprintf(slask,"<WIDTH>%ld</WIDTH>",this -> width);
00758         dest += slask;
00759         sprintf(slask,"<HEIGHT>%ld</HEIGHT>",this -> height);
00760         dest += slask;
00761         dest += "</AREA>";
00762         return dest;
00763 }
00764 
00765 
00766 std::string Area::xml(const std::string& tag,const std::string& xvalx)
00767 {
00768         Query q(*database);
00769         std::string dest;
00770         char slask[200];
00771         dest = "<AREA " + tag + "=\"" + xvalx + "\">";
00772         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00773         dest += slask;
00774         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00775         sprintf(slask,"<WIDTH>%ld</WIDTH>",this -> width);
00776         dest += slask;
00777         sprintf(slask,"<HEIGHT>%ld</HEIGHT>",this -> height);
00778         dest += slask;
00779         dest += "</AREA>";
00780         return dest;
00781 }
00782 
00783 
00784 size_t Area::num_cols()
00785 {
00786         return 4;
00787 }
00788 
00789 
00790 void Area::clear()
00791 {
00792         this -> num = 0;
00793         this -> name = "";
00794         this -> width = 0;
00795         this -> height = 0;
00796 }
00797 
00798 
00799 void Area::spawn(const std::string& sql)
00800 {
00801         Query q(*database);
00802         std::string temp;
00803 
00804         clear();
00805 
00806         if (!strncasecmp(sql.c_str(),"select * ",9))
00807         {
00808                 temp = "select num,name,width,height " + sql.substr(9);
00809         } else
00810                 temp = sql;
00811         q.get_result(temp);
00812         if (q.fetch_row())
00813         {
00814                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
00815                 this -> name = q.getstr(1);                                                                                                                                                             // 1 - name varchar(255)
00816                 this -> width = q.getval(2);                                                                                                                                                            // 2 - width integer
00817                 this -> height = q.getval(3);                                                                                                                                                           // 3 - height integer
00818                 new_object = 0;
00819         } else
00820                 clear();
00821         q.free_result();
00822 }
00823 
00824 
00825 void Area::spawn(Query *qd,int offset)
00826 {
00827         clear();
00828 
00829         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
00830         this -> name = qd -> getstr(1 + offset);                                                                                                                                                                // 1 - name varchar(255)
00831         this -> width = qd -> getval(2 + offset);                                                                                                                                                               // 2 - width integer
00832         this -> height = qd -> getval(3 + offset);                                                                                                                                                              // 3 - height integer
00833 }
00834 
00835 
00836 // End of implementation of class 'Area'
00837 
00838 } // End of namespace
00839 namespace db {
00840 
00845 Chunk::Chunk(Database *db)
00846 {
00847         database = db;
00848         new_object = 1;
00849         clear();
00850 }
00851 
00852 
00853 Chunk::Chunk(Database *db,const std::string& sql)
00854 {
00855         database = db;
00856         new_object = 1;
00857         spawn(sql);
00858 }
00859 
00860 
00861 Chunk::Chunk(Database *db,Query *qd,int offset)
00862 {
00863         database = db;
00864         new_object = 0;
00865         spawn(qd, offset);
00866 }
00867 
00868 
00869 Chunk::Chunk(Database& db,long i_num):database(&db),new_object(1)
00870 {
00871         Query q(*database);
00872         std::string sql = "select * from chunk where ";
00873         {
00874                 char slask[100];
00875                 sprintf(slask,"num='%ld'",i_num);
00876                 sql += slask;
00877         }
00878         spawn(sql);
00879 }
00880 
00881 
00882 Chunk::Chunk(Database& db,long i_area,long i_x,long i_y,long i_z):database(&db),new_object(1)
00883 {
00884         Query q(*database);
00885         std::string sql = "select * from chunk where ";
00886         {
00887                 char slask[100];
00888                 sprintf(slask,"area='%ld'",i_area);
00889                 sql += slask;
00890         }
00891         {
00892                 char slask[100];
00893                 sprintf(slask," and x='%ld'",i_x);
00894                 sql += slask;
00895         }
00896         {
00897                 char slask[100];
00898                 sprintf(slask," and y='%ld'",i_y);
00899                 sql += slask;
00900         }
00901         {
00902                 char slask[100];
00903                 sprintf(slask," and z='%ld'",i_z);
00904                 sql += slask;
00905         }
00906         spawn(sql);
00907 }
00908 
00909 
00910 Chunk::~Chunk()
00911 {
00912 }
00913 
00914 
00915 void Chunk::select(const std::string& sql)
00916 {
00917         spawn(sql);
00918 }
00919 
00920 
00921 unsigned long long int Chunk::insert()
00922 {
00923         Query q(*database);
00924         std::string sql;
00925 
00926         sql = "insert into chunk(area,terrain,x,y,z,created_by,created_date)";
00927         {
00928                 char slask[100];
00929                 sprintf(slask," values(%ld",this -> area);
00930                 sql += slask;
00931         }
00932         sql += ", '" + q.GetDatabase().safestr(this -> terrain) + "'";
00933         {
00934                 char slask[100];
00935                 sprintf(slask,", %ld",this -> x);
00936                 sql += slask;
00937         }
00938         {
00939                 char slask[100];
00940                 sprintf(slask,", %ld",this -> y);
00941                 sql += slask;
00942         }
00943         {
00944                 char slask[100];
00945                 sprintf(slask,", %ld",this -> z);
00946                 sql += slask;
00947         }
00948         {
00949                 char slask[100];
00950                 sprintf(slask,", %ld",this -> created_by);
00951                 sql += slask;
00952         }
00953         sql += ", '" + q.GetDatabase().safestr(this -> created_date) + "'";
00954         sql += ")";
00955         q.execute(sql);
00956         new_object = 0;
00957         unsigned long long int inserted_id = q.insert_id();
00958         num = inserted_id;
00959         return inserted_id;
00960 }
00961 
00962 
00963 void Chunk::update()
00964 {
00965         update(this -> num);
00966 }
00967 
00968 
00969 void Chunk::update(long i_num)
00970 {
00971         Query q(*database);
00972         std::string sql;
00973         {
00974                 char slask[200];
00975                 sprintf(slask,"update chunk set area=%ld",this -> area);
00976                 sql += slask;
00977         }
00978         sql += ", terrain='" + q.GetDatabase().safestr(this -> terrain) + "'";
00979         {
00980                 char slask[200];
00981                 sprintf(slask,", x=%ld",this -> x);
00982                 sql += slask;
00983         }
00984         {
00985                 char slask[200];
00986                 sprintf(slask,", y=%ld",this -> y);
00987                 sql += slask;
00988         }
00989         {
00990                 char slask[200];
00991                 sprintf(slask,", z=%ld",this -> z);
00992                 sql += slask;
00993         }
00994         {
00995                 char slask[200];
00996                 sprintf(slask,", created_by=%ld",this -> created_by);
00997                 sql += slask;
00998         }
00999         sql += ", created_date='" + q.GetDatabase().safestr(this -> created_date) + "'";
01000         {
01001                 char slask[200];
01002                 sprintf(slask," where num='%ld'",i_num);
01003                 sql += slask;
01004         }
01005         q.execute(sql);
01006 }
01007 
01008 
01009 void Chunk::save()
01010 {
01011         if (new_object)
01012                 insert();
01013         else
01014                 update();
01015 }
01016 
01017 
01018 void Chunk::erase()
01019 {
01020         if (!new_object)
01021         {
01022                 std::string sql = "delete from chunk where";
01023                 Query q(*database);
01024                 {
01025                         char slask[200];
01026                         sprintf(slask," num='%ld'",this -> num);
01027                         sql += slask;
01028                 }
01029                 q.execute(sql);
01030         }
01031 }
01032 
01033 
01034 std::string Chunk::xml()
01035 {
01036         Query q(*database);
01037         std::string dest;
01038         char slask[200];
01039         dest = "<CHUNK>";
01040         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01041         dest += slask;
01042         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01043         dest += slask;
01044         dest += "<TERRAIN>" + q.GetDatabase().xmlsafestr(this -> terrain) + "</TERRAIN>";
01045         sprintf(slask,"<X>%ld</X>",this -> x);
01046         dest += slask;
01047         sprintf(slask,"<Y>%ld</Y>",this -> y);
01048         dest += slask;
01049         sprintf(slask,"<Z>%ld</Z>",this -> z);
01050         dest += slask;
01051         sprintf(slask,"<CREATED_BY>%ld</CREATED_BY>",this -> created_by);
01052         dest += slask;
01053         dest += "<CREATED_DATE>" + q.GetDatabase().xmlsafestr(this -> created_date) + "</CREATED_DATE>";
01054         dest += "</CHUNK>";
01055         return dest;
01056 }
01057 
01058 
01059 std::string Chunk::xml(const std::string& tag,const std::string& xvalx)
01060 {
01061         Query q(*database);
01062         std::string dest;
01063         char slask[200];
01064         dest = "<CHUNK " + tag + "=\"" + xvalx + "\">";
01065         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01066         dest += slask;
01067         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01068         dest += slask;
01069         dest += "<TERRAIN>" + q.GetDatabase().xmlsafestr(this -> terrain) + "</TERRAIN>";
01070         sprintf(slask,"<X>%ld</X>",this -> x);
01071         dest += slask;
01072         sprintf(slask,"<Y>%ld</Y>",this -> y);
01073         dest += slask;
01074         sprintf(slask,"<Z>%ld</Z>",this -> z);
01075         dest += slask;
01076         sprintf(slask,"<CREATED_BY>%ld</CREATED_BY>",this -> created_by);
01077         dest += slask;
01078         dest += "<CREATED_DATE>" + q.GetDatabase().xmlsafestr(this -> created_date) + "</CREATED_DATE>";
01079         dest += "</CHUNK>";
01080         return dest;
01081 }
01082 
01083 
01084 size_t Chunk::num_cols()
01085 {
01086         return 8;
01087 }
01088 
01089 
01090 void Chunk::clear()
01091 {
01092         this -> num = 0;
01093         this -> area = 0;
01094         this -> terrain = "";
01095         this -> x = 0;
01096         this -> y = 0;
01097         this -> z = 0;
01098         this -> created_by = 0;
01099         this -> created_date = "";
01100 }
01101 
01102 
01103 void Chunk::spawn(const std::string& sql)
01104 {
01105         Query q(*database);
01106         std::string temp;
01107 
01108         clear();
01109 
01110         if (!strncasecmp(sql.c_str(),"select * ",9))
01111         {
01112                 temp = "select num,area,terrain,x,y,z,created_by,created_date " + sql.substr(9);
01113         } else
01114                 temp = sql;
01115         q.get_result(temp);
01116         if (q.fetch_row())
01117         {
01118                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
01119                 this -> area = q.getval(1);                                                                                                                                                             // 1 - area integer
01120                 this -> terrain = q.getstr(2);                                                                                                                                                          // 2 - terrain text
01121                 this -> x = q.getval(3);                                                                                                                                                                // 3 - x integer
01122                 this -> y = q.getval(4);                                                                                                                                                                // 4 - y integer
01123                 this -> z = q.getval(5);                                                                                                                                                                // 5 - z integer
01124                 this -> created_by = q.getval(6);                                                                                                                                                               // 6 - created_by integer
01125                 this -> created_date = q.getstr(7);                                                                                                                                                             // 7 - created_date datetime
01126                 new_object = 0;
01127         } else
01128                 clear();
01129         q.free_result();
01130 }
01131 
01132 
01133 void Chunk::spawn(Query *qd,int offset)
01134 {
01135         clear();
01136 
01137         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
01138         this -> area = qd -> getval(1 + offset);                                                                                                                                                                // 1 - area integer
01139         this -> terrain = qd -> getstr(2 + offset);                                                                                                                                                             // 2 - terrain text
01140         this -> x = qd -> getval(3 + offset);                                                                                                                                                           // 3 - x integer
01141         this -> y = qd -> getval(4 + offset);                                                                                                                                                           // 4 - y integer
01142         this -> z = qd -> getval(5 + offset);                                                                                                                                                           // 5 - z integer
01143         this -> created_by = qd -> getval(6 + offset);                                                                                                                                                          // 6 - created_by integer
01144         this -> created_date = qd -> getstr(7 + offset);                                                                                                                                                                // 7 - created_date datetime
01145 }
01146 
01147 
01148 // End of implementation of class 'Chunk'
01149 
01150 } // End of namespace
01151 namespace db {
01152 
01157 Chunkinfo::Chunkinfo(Database *db)
01158 {
01159         database = db;
01160         new_object = 1;
01161         clear();
01162 }
01163 
01164 
01165 Chunkinfo::Chunkinfo(Database *db,const std::string& sql)
01166 {
01167         database = db;
01168         new_object = 1;
01169         spawn(sql);
01170 }
01171 
01172 
01173 Chunkinfo::Chunkinfo(Database *db,Query *qd,int offset)
01174 {
01175         database = db;
01176         new_object = 0;
01177         spawn(qd, offset);
01178 }
01179 
01180 
01181 Chunkinfo::Chunkinfo(Database& db,long i_num):database(&db),new_object(1)
01182 {
01183         Query q(*database);
01184         std::string sql = "select * from chunkinfo where ";
01185         {
01186                 char slask[100];
01187                 sprintf(slask,"num='%ld'",i_num);
01188                 sql += slask;
01189         }
01190         spawn(sql);
01191 }
01192 
01193 
01194 Chunkinfo::Chunkinfo(Database& db,long i_chunk,long i_type,long i_x,long i_y):database(&db),new_object(1)
01195 {
01196         Query q(*database);
01197         std::string sql = "select * from chunkinfo where ";
01198         {
01199                 char slask[100];
01200                 sprintf(slask,"chunk='%ld'",i_chunk);
01201                 sql += slask;
01202         }
01203         {
01204                 char slask[100];
01205                 sprintf(slask," and type='%ld'",i_type);
01206                 sql += slask;
01207         }
01208         {
01209                 char slask[100];
01210                 sprintf(slask," and x='%ld'",i_x);
01211                 sql += slask;
01212         }
01213         {
01214                 char slask[100];
01215                 sprintf(slask," and y='%ld'",i_y);
01216                 sql += slask;
01217         }
01218         spawn(sql);
01219 }
01220 
01221 
01222 Chunkinfo::~Chunkinfo()
01223 {
01224 }
01225 
01226 
01227 void Chunkinfo::select(const std::string& sql)
01228 {
01229         spawn(sql);
01230 }
01231 
01232 
01233 unsigned long long int Chunkinfo::insert()
01234 {
01235         Query q(*database);
01236         std::string sql;
01237 
01238         sql = "insert into chunkinfo(chunk,type,x,y,data,to_area,to_chunk,to_x,to_y)";
01239         {
01240                 char slask[100];
01241                 sprintf(slask," values(%ld",this -> chunk);
01242                 sql += slask;
01243         }
01244         {
01245                 char slask[100];
01246                 sprintf(slask,", %ld",this -> type);
01247                 sql += slask;
01248         }
01249         {
01250                 char slask[100];
01251                 sprintf(slask,", %ld",this -> x);
01252                 sql += slask;
01253         }
01254         {
01255                 char slask[100];
01256                 sprintf(slask,", %ld",this -> y);
01257                 sql += slask;
01258         }
01259         sql += ", '" + q.GetDatabase().safestr(this -> data) + "'";
01260         {
01261                 char slask[100];
01262                 sprintf(slask,", %ld",this -> to_area);
01263                 sql += slask;
01264         }
01265         {
01266                 char slask[100];
01267                 sprintf(slask,", %ld",this -> to_chunk);
01268                 sql += slask;
01269         }
01270         {
01271                 char slask[100];
01272                 sprintf(slask,", %ld",this -> to_x);
01273                 sql += slask;
01274         }
01275         {
01276                 char slask[100];
01277                 sprintf(slask,", %ld",this -> to_y);
01278                 sql += slask;
01279         }
01280         sql += ")";
01281         q.execute(sql);
01282         new_object = 0;
01283         unsigned long long int inserted_id = q.insert_id();
01284         num = inserted_id;
01285         return inserted_id;
01286 }
01287 
01288 
01289 void Chunkinfo::update()
01290 {
01291         update(this -> num);
01292 }
01293 
01294 
01295 void Chunkinfo::update(long i_num)
01296 {
01297         Query q(*database);
01298         std::string sql;
01299         {
01300                 char slask[200];
01301                 sprintf(slask,"update chunkinfo set chunk=%ld",this -> chunk);
01302                 sql += slask;
01303         }
01304         {
01305                 char slask[200];
01306                 sprintf(slask,", type=%ld",this -> type);
01307                 sql += slask;
01308         }
01309         {
01310                 char slask[200];
01311                 sprintf(slask,", x=%ld",this -> x);
01312                 sql += slask;
01313         }
01314         {
01315                 char slask[200];
01316                 sprintf(slask,", y=%ld",this -> y);
01317                 sql += slask;
01318         }
01319         sql += ", data='" + q.GetDatabase().safestr(this -> data) + "'";
01320         {
01321                 char slask[200];
01322                 sprintf(slask,", to_area=%ld",this -> to_area);
01323                 sql += slask;
01324         }
01325         {
01326                 char slask[200];
01327                 sprintf(slask,", to_chunk=%ld",this -> to_chunk);
01328                 sql += slask;
01329         }
01330         {
01331                 char slask[200];
01332                 sprintf(slask,", to_x=%ld",this -> to_x);
01333                 sql += slask;
01334         }
01335         {
01336                 char slask[200];
01337                 sprintf(slask,", to_y=%ld",this -> to_y);
01338                 sql += slask;
01339         }
01340         {
01341                 char slask[200];
01342                 sprintf(slask," where num='%ld'",i_num);
01343                 sql += slask;
01344         }
01345         q.execute(sql);
01346 }
01347 
01348 
01349 void Chunkinfo::save()
01350 {
01351         if (new_object)
01352                 insert();
01353         else
01354                 update();
01355 }
01356 
01357 
01358 void Chunkinfo::erase()
01359 {
01360         if (!new_object)
01361         {
01362                 std::string sql = "delete from chunkinfo where";
01363                 Query q(*database);
01364                 {
01365                         char slask[200];
01366                         sprintf(slask," num='%ld'",this -> num);
01367                         sql += slask;
01368                 }
01369                 q.execute(sql);
01370         }
01371 }
01372 
01373 
01374 std::string Chunkinfo::xml()
01375 {
01376         Query q(*database);
01377         std::string dest;
01378         char slask[200];
01379         dest = "<CHUNKINFO>";
01380         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01381         dest += slask;
01382         sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
01383         dest += slask;
01384         sprintf(slask,"<TYPE>%ld</TYPE>",this -> type);
01385         dest += slask;
01386         sprintf(slask,"<X>%ld</X>",this -> x);
01387         dest += slask;
01388         sprintf(slask,"<Y>%ld</Y>",this -> y);
01389         dest += slask;
01390         dest += "<DATA>" + q.GetDatabase().xmlsafestr(this -> data) + "</DATA>";
01391         sprintf(slask,"<TO_AREA>%ld</TO_AREA>",this -> to_area);
01392         dest += slask;
01393         sprintf(slask,"<TO_CHUNK>%ld</TO_CHUNK>",this -> to_chunk);
01394         dest += slask;
01395         sprintf(slask,"<TO_X>%ld</TO_X>",this -> to_x);
01396         dest += slask;
01397         sprintf(slask,"<TO_Y>%ld</TO_Y>",this -> to_y);
01398         dest += slask;
01399         dest += "</CHUNKINFO>";
01400         return dest;
01401 }
01402 
01403 
01404 std::string Chunkinfo::xml(const std::string& tag,const std::string& xvalx)
01405 {
01406         Query q(*database);
01407         std::string dest;
01408         char slask[200];
01409         dest = "<CHUNKINFO " + tag + "=\"" + xvalx + "\">";
01410         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01411         dest += slask;
01412         sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
01413         dest += slask;
01414         sprintf(slask,"<TYPE>%ld</TYPE>",this -> type);
01415         dest += slask;
01416         sprintf(slask,"<X>%ld</X>",this -> x);
01417         dest += slask;
01418         sprintf(slask,"<Y>%ld</Y>",this -> y);
01419         dest += slask;
01420         dest += "<DATA>" + q.GetDatabase().xmlsafestr(this -> data) + "</DATA>";
01421         sprintf(slask,"<TO_AREA>%ld</TO_AREA>",this -> to_area);
01422         dest += slask;
01423         sprintf(slask,"<TO_CHUNK>%ld</TO_CHUNK>",this -> to_chunk);
01424         dest += slask;
01425         sprintf(slask,"<TO_X>%ld</TO_X>",this -> to_x);
01426         dest += slask;
01427         sprintf(slask,"<TO_Y>%ld</TO_Y>",this -> to_y);
01428         dest += slask;
01429         dest += "</CHUNKINFO>";
01430         return dest;
01431 }
01432 
01433 
01434 size_t Chunkinfo::num_cols()
01435 {
01436         return 10;
01437 }
01438 
01439 
01440 void Chunkinfo::clear()
01441 {
01442         this -> num = 0;
01443         this -> chunk = 0;
01444         this -> type = 0;
01445         this -> x = 0;
01446         this -> y = 0;
01447         this -> data = "";
01448         this -> to_area = 0;
01449         this -> to_chunk = 0;
01450         this -> to_x = 0;
01451         this -> to_y = 0;
01452 }
01453 
01454 
01455 void Chunkinfo::spawn(const std::string& sql)
01456 {
01457         Query q(*database);
01458         std::string temp;
01459 
01460         clear();
01461 
01462         if (!strncasecmp(sql.c_str(),"select * ",9))
01463         {
01464                 temp = "select num,chunk,type,x,y,data,to_area,to_chunk,to_x,to_y " + sql.substr(9);
01465         } else
01466                 temp = sql;
01467         q.get_result(temp);
01468         if (q.fetch_row())
01469         {
01470                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
01471                 this -> chunk = q.getval(1);                                                                                                                                                            // 1 - chunk integer
01472                 this -> type = q.getval(2);                                                                                                                                                             // 2 - type integer
01473                 this -> x = q.getval(3);                                                                                                                                                                // 3 - x integer
01474                 this -> y = q.getval(4);                                                                                                                                                                // 4 - y integer
01475                 this -> data = q.getstr(5);                                                                                                                                                             // 5 - data varchar(255)
01476                 this -> to_area = q.getval(6);                                                                                                                                                          // 6 - to_area integer
01477                 this -> to_chunk = q.getval(7);                                                                                                                                                         // 7 - to_chunk integer
01478                 this -> to_x = q.getval(8);                                                                                                                                                             // 8 - to_x integer
01479                 this -> to_y = q.getval(9);                                                                                                                                                             // 9 - to_y integer
01480                 new_object = 0;
01481         } else
01482                 clear();
01483         q.free_result();
01484 }
01485 
01486 
01487 void Chunkinfo::spawn(Query *qd,int offset)
01488 {
01489         clear();
01490 
01491         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
01492         this -> chunk = qd -> getval(1 + offset);                                                                                                                                                               // 1 - chunk integer
01493         this -> type = qd -> getval(2 + offset);                                                                                                                                                                // 2 - type integer
01494         this -> x = qd -> getval(3 + offset);                                                                                                                                                           // 3 - x integer
01495         this -> y = qd -> getval(4 + offset);                                                                                                                                                           // 4 - y integer
01496         this -> data = qd -> getstr(5 + offset);                                                                                                                                                                // 5 - data varchar(255)
01497         this -> to_area = qd -> getval(6 + offset);                                                                                                                                                             // 6 - to_area integer
01498         this -> to_chunk = qd -> getval(7 + offset);                                                                                                                                                            // 7 - to_chunk integer
01499         this -> to_x = qd -> getval(8 + offset);                                                                                                                                                                // 8 - to_x integer
01500         this -> to_y = qd -> getval(9 + offset);                                                                                                                                                                // 9 - to_y integer
01501 }
01502 
01503 
01504 // End of implementation of class 'Chunkinfo'
01505 
01506 } // End of namespace
01507 namespace db {
01508 
01513 Terrain::Terrain(Database *db)
01514 {
01515         database = db;
01516         new_object = 1;
01517         clear();
01518 }
01519 
01520 
01521 Terrain::Terrain(Database *db,const std::string& sql)
01522 {
01523         database = db;
01524         new_object = 1;
01525         spawn(sql);
01526 }
01527 
01528 
01529 Terrain::Terrain(Database *db,Query *qd,int offset)
01530 {
01531         database = db;
01532         new_object = 0;
01533         spawn(qd, offset);
01534 }
01535 
01536 
01537 Terrain::Terrain(Database& db,long i_num):database(&db),new_object(1)
01538 {
01539         Query q(*database);
01540         std::string sql = "select * from terrain where ";
01541         {
01542                 char slask[100];
01543                 sprintf(slask,"num='%ld'",i_num);
01544                 sql += slask;
01545         }
01546         spawn(sql);
01547 }
01548 
01549 
01550 Terrain::Terrain(Database& db,long i_area,const std::string&  i_tchar):database(&db),new_object(1)
01551 {
01552         Query q(*database);
01553         std::string sql = "select * from terrain where ";
01554         {
01555                 char slask[100];
01556                 sprintf(slask,"area='%ld'",i_area);
01557                 sql += slask;
01558         }
01559         sql += " and tchar='" + q.GetDatabase().safestr(i_tchar) + "'";
01560         spawn(sql);
01561 }
01562 
01563 
01564 Terrain::~Terrain()
01565 {
01566 }
01567 
01568 
01569 void Terrain::select(const std::string& sql)
01570 {
01571         spawn(sql);
01572 }
01573 
01574 
01575 unsigned long long int Terrain::insert()
01576 {
01577         Query q(*database);
01578         std::string sql;
01579 
01580         sql = "insert into terrain(area,name,tchar,tcolor,impassable,delay)";
01581         {
01582                 char slask[100];
01583                 sprintf(slask," values(%ld",this -> area);
01584                 sql += slask;
01585         }
01586         sql += ", '" + q.GetDatabase().safestr(this -> name) + "'";
01587         sql += ", '" + q.GetDatabase().safestr(this -> tchar) + "'";
01588         sql += ", '" + q.GetDatabase().safestr(this -> tcolor) + "'";
01589         {
01590                 char slask[100];
01591                 sprintf(slask,", %ld",this -> impassable);
01592                 sql += slask;
01593         }
01594         {
01595                 char slask[100];
01596                 sprintf(slask,", %f",this -> delay);
01597                 sql += slask;
01598         }
01599         sql += ")";
01600         q.execute(sql);
01601         new_object = 0;
01602         unsigned long long int inserted_id = q.insert_id();
01603         num = inserted_id;
01604         return inserted_id;
01605 }
01606 
01607 
01608 void Terrain::update()
01609 {
01610         update(this -> num);
01611 }
01612 
01613 
01614 void Terrain::update(long i_num)
01615 {
01616         Query q(*database);
01617         std::string sql;
01618         {
01619                 char slask[200];
01620                 sprintf(slask,"update terrain set area=%ld",this -> area);
01621                 sql += slask;
01622         }
01623         sql += ", name='" + q.GetDatabase().safestr(this -> name) + "'";
01624         sql += ", tchar='" + q.GetDatabase().safestr(this -> tchar) + "'";
01625         sql += ", tcolor='" + q.GetDatabase().safestr(this -> tcolor) + "'";
01626         {
01627                 char slask[200];
01628                 sprintf(slask,", impassable=%ld",this -> impassable);
01629                 sql += slask;
01630         }
01631         {
01632                 char slask[200];
01633                 sprintf(slask,", delay='%f'",this -> delay);
01634                 sql += slask;
01635         }
01636         {
01637                 char slask[200];
01638                 sprintf(slask," where num='%ld'",i_num);
01639                 sql += slask;
01640         }
01641         q.execute(sql);
01642 }
01643 
01644 
01645 void Terrain::save()
01646 {
01647         if (new_object)
01648                 insert();
01649         else
01650                 update();
01651 }
01652 
01653 
01654 void Terrain::erase()
01655 {
01656         if (!new_object)
01657         {
01658                 std::string sql = "delete from terrain where";
01659                 Query q(*database);
01660                 {
01661                         char slask[200];
01662                         sprintf(slask," num='%ld'",this -> num);
01663                         sql += slask;
01664                 }
01665                 q.execute(sql);
01666         }
01667 }
01668 
01669 
01670 std::string Terrain::xml()
01671 {
01672         Query q(*database);
01673         std::string dest;
01674         char slask[200];
01675         dest = "<TERRAIN>";
01676         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01677         dest += slask;
01678         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01679         dest += slask;
01680         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
01681         dest += "<TCHAR>" + q.GetDatabase().xmlsafestr(this -> tchar) + "</TCHAR>";
01682         dest += "<TCOLOR>" + q.GetDatabase().xmlsafestr(this -> tcolor) + "</TCOLOR>";
01683         sprintf(slask,"<IMPASSABLE>%ld</IMPASSABLE>",this -> impassable);
01684         dest += slask;
01685         sprintf(slask,"<DELAY>%f</DELAY>",this -> delay);
01686         dest += slask;
01687         dest += "</TERRAIN>";
01688         return dest;
01689 }
01690 
01691 
01692 std::string Terrain::xml(const std::string& tag,const std::string& xvalx)
01693 {
01694         Query q(*database);
01695         std::string dest;
01696         char slask[200];
01697         dest = "<TERRAIN " + tag + "=\"" + xvalx + "\">";
01698         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01699         dest += slask;
01700         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01701         dest += slask;
01702         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
01703         dest += "<TCHAR>" + q.GetDatabase().xmlsafestr(this -> tchar) + "</TCHAR>";
01704         dest += "<TCOLOR>" + q.GetDatabase().xmlsafestr(this -> tcolor) + "</TCOLOR>";
01705         sprintf(slask,"<IMPASSABLE>%ld</IMPASSABLE>",this -> impassable);
01706         dest += slask;
01707         sprintf(slask,"<DELAY>%f</DELAY>",this -> delay);
01708         dest += slask;
01709         dest += "</TERRAIN>";
01710         return dest;
01711 }
01712 
01713 
01714 size_t Terrain::num_cols()
01715 {
01716         return 7;
01717 }
01718 
01719 
01720 void Terrain::clear()
01721 {
01722         this -> num = 0;
01723         this -> area = 0;
01724         this -> name = "";
01725         this -> tchar = "";
01726         this -> tcolor = "";
01727         this -> impassable = 0;
01728         this -> delay = 0;
01729 }
01730 
01731 
01732 void Terrain::spawn(const std::string& sql)
01733 {
01734         Query q(*database);
01735         std::string temp;
01736 
01737         clear();
01738 
01739         if (!strncasecmp(sql.c_str(),"select * ",9))
01740         {
01741                 temp = "select num,area,name,tchar,tcolor,impassable,delay " + sql.substr(9);
01742         } else
01743                 temp = sql;
01744         q.get_result(temp);
01745         if (q.fetch_row())
01746         {
01747                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
01748                 this -> area = q.getval(1);                                                                                                                                                             // 1 - area integer
01749                 this -> name = q.getstr(2);                                                                                                                                                             // 2 - name varchar(255)
01750                 this -> tchar = q.getstr(3);                                                                                                                                                            // 3 - tchar char(1)
01751                 this -> tcolor = q.getstr(4);                                                                                                                                                           // 4 - tcolor varchar(10)
01752                 this -> impassable = q.getval(5);                                                                                                                                                               // 5 - impassable integer
01753                 this -> delay = q.getnum(6);                                                                                                                                                            // 6 - delay float
01754                 new_object = 0;
01755         } else
01756                 clear();
01757         q.free_result();
01758 }
01759 
01760 
01761 void Terrain::spawn(Query *qd,int offset)
01762 {
01763         clear();
01764 
01765         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
01766         this -> area = qd -> getval(1 + offset);                                                                                                                                                                // 1 - area integer
01767         this -> name = qd -> getstr(2 + offset);                                                                                                                                                                // 2 - name varchar(255)
01768         this -> tchar = qd -> getstr(3 + offset);                                                                                                                                                               // 3 - tchar char(1)
01769         this -> tcolor = qd -> getstr(4 + offset);                                                                                                                                                              // 4 - tcolor varchar(10)
01770         this -> impassable = qd -> getval(5 + offset);                                                                                                                                                          // 5 - impassable integer
01771         this -> delay = qd -> getnum(6 + offset);                                                                                                                                                               // 6 - delay float
01772 }
01773 
01774 
01775 // End of implementation of class 'Terrain'
01776 
01777 } // End of namespace
01778 namespace db {
01779 
01784 Steps::Steps(Database *db)
01785 {
01786         database = db;
01787         new_object = 1;
01788         clear();
01789 }
01790 
01791 
01792 Steps::Steps(Database *db,const std::string& sql)
01793 {
01794         database = db;
01795         new_object = 1;
01796         spawn(sql);
01797 }
01798 
01799 
01800 Steps::Steps(Database *db,Query *qd,int offset)
01801 {
01802         database = db;
01803         new_object = 0;
01804         spawn(qd, offset);
01805 }
01806 
01807 
01808 Steps::Steps(Database& db,long i_num):database(&db),new_object(1)
01809 {
01810         Query q(*database);
01811         std::string sql = "select * from steps where ";
01812         {
01813                 char slask[100];
01814                 sprintf(slask,"num='%ld'",i_num);
01815                 sql += slask;
01816         }
01817         spawn(sql);
01818 }
01819 
01820 
01821 Steps::Steps(Database& db,long i_player,long i_area,long i_zcoord,long i_ycoord):database(&db),new_object(1)
01822 {
01823         Query q(*database);
01824         std::string sql = "select * from steps where ";
01825         {
01826                 char slask[100];
01827                 sprintf(slask,"player='%ld'",i_player);
01828                 sql += slask;
01829         }
01830         {
01831                 char slask[100];
01832                 sprintf(slask," and area='%ld'",i_area);
01833                 sql += slask;
01834         }
01835         {
01836                 char slask[100];
01837                 sprintf(slask," and zcoord='%ld'",i_zcoord);
01838                 sql += slask;
01839         }
01840         {
01841                 char slask[100];
01842                 sprintf(slask," and ycoord='%ld'",i_ycoord);
01843                 sql += slask;
01844         }
01845         spawn(sql);
01846 }
01847 
01848 
01849 Steps::~Steps()
01850 {
01851 }
01852 
01853 
01854 void Steps::select(const std::string& sql)
01855 {
01856         spawn(sql);
01857 }
01858 
01859 
01860 unsigned long long int Steps::insert()
01861 {
01862         Query q(*database);
01863         std::string sql;
01864 
01865         sql = "insert into steps(player,area,zcoord,ycoord,xcoords)";
01866         {
01867                 char slask[100];
01868                 sprintf(slask," values(%ld",this -> player);
01869                 sql += slask;
01870         }
01871         {
01872                 char slask[100];
01873                 sprintf(slask,", %ld",this -> area);
01874                 sql += slask;
01875         }
01876         {
01877                 char slask[100];
01878                 sprintf(slask,", %ld",this -> zcoord);
01879                 sql += slask;
01880         }
01881         {
01882                 char slask[100];
01883                 sprintf(slask,", %ld",this -> ycoord);
01884                 sql += slask;
01885         }
01886         sql += ", '" + q.GetDatabase().safestr(this -> xcoords) + "'";
01887         sql += ")";
01888         q.execute(sql);
01889         new_object = 0;
01890         unsigned long long int inserted_id = q.insert_id();
01891         num = inserted_id;
01892         return inserted_id;
01893 }
01894 
01895 
01896 void Steps::update()
01897 {
01898         update(this -> num);
01899 }
01900 
01901 
01902 void Steps::update(long i_num)
01903 {
01904         Query q(*database);
01905         std::string sql;
01906         {
01907                 char slask[200];
01908                 sprintf(slask,"update steps set player=%ld",this -> player);
01909                 sql += slask;
01910         }
01911         {
01912                 char slask[200];
01913                 sprintf(slask,", area=%ld",this -> area);
01914                 sql += slask;
01915         }
01916         {
01917                 char slask[200];
01918                 sprintf(slask,", zcoord=%ld",this -> zcoord);
01919                 sql += slask;
01920         }
01921         {
01922                 char slask[200];
01923                 sprintf(slask,", ycoord=%ld",this -> ycoord);
01924                 sql += slask;
01925         }
01926         sql += ", xcoords='" + q.GetDatabase().safestr(this -> xcoords) + "'";
01927         {
01928                 char slask[200];
01929                 sprintf(slask," where num='%ld'",i_num);
01930                 sql += slask;
01931         }
01932         q.execute(sql);
01933 }
01934 
01935 
01936 void Steps::save()
01937 {
01938         if (new_object)
01939                 insert();
01940         else
01941                 update();
01942 }
01943 
01944 
01945 void Steps::erase()
01946 {
01947         if (!new_object)
01948         {
01949                 std::string sql = "delete from steps where";
01950                 Query q(*database);
01951                 {
01952                         char slask[200];
01953                         sprintf(slask," num='%ld'",this -> num);
01954                         sql += slask;
01955                 }
01956                 q.execute(sql);
01957         }
01958 }
01959 
01960 
01961 std::string Steps::xml()
01962 {
01963         Query q(*database);
01964         std::string dest;
01965         char slask[200];
01966         dest = "<STEPS>";
01967         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01968         dest += slask;
01969         sprintf(slask,"<PLAYER>%ld</PLAYER>",this -> player);
01970         dest += slask;
01971         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01972         dest += slask;
01973         sprintf(slask,"<ZCOORD>%ld</ZCOORD>",this -> zcoord);
01974         dest += slask;
01975         sprintf(slask,"<YCOORD>%ld</YCOORD>",this -> ycoord);
01976         dest += slask;
01977         dest += "<XCOORDS>" + q.GetDatabase().xmlsafestr(this -> xcoords) + "</XCOORDS>";
01978         dest += "</STEPS>";
01979         return dest;
01980 }
01981 
01982 
01983 std::string Steps::xml(const std::string& tag,const std::string& xvalx)
01984 {
01985         Query q(*database);
01986         std::string dest;
01987         char slask[200];
01988         dest = "<STEPS " + tag + "=\"" + xvalx + "\">";
01989         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01990         dest += slask;
01991         sprintf(slask,"<PLAYER>%ld</PLAYER>",this -> player);
01992         dest += slask;
01993         sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01994         dest += slask;
01995         sprintf(slask,"<ZCOORD>%ld</ZCOORD>",this -> zcoord);
01996         dest += slask;
01997         sprintf(slask,"<YCOORD>%ld</YCOORD>",this -> ycoord);
01998         dest += slask;
01999         dest += "<XCOORDS>" + q.GetDatabase().xmlsafestr(this -> xcoords) + "</XCOORDS>";
02000         dest += "</STEPS>";
02001         return dest;
02002 }
02003 
02004 
02005 size_t Steps::num_cols()
02006 {
02007         return 6;
02008 }
02009 
02010 
02011 void Steps::clear()
02012 {
02013         this -> num = 0;
02014         this -> player = 0;
02015         this -> area = 0;
02016         this -> zcoord = 0;
02017         this -> ycoord = 0;
02018         this -> xcoords = "";
02019 }
02020 
02021 
02022 void Steps::spawn(const std::string& sql)
02023 {
02024         Query q(*database);
02025         std::string temp;
02026 
02027         clear();
02028 
02029         if (!strncasecmp(sql.c_str(),"select * ",9))
02030         {
02031                 temp = "select num,player,area,zcoord,ycoord,xcoords " + sql.substr(9);
02032         } else
02033                 temp = sql;
02034         q.get_result(temp);
02035         if (q.fetch_row())
02036         {
02037                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
02038                 this -> player = q.getval(1);                                                                                                                                                           // 1 - player integer
02039                 this -> area = q.getval(2);                                                                                                                                                             // 2 - area integer
02040                 this -> zcoord = q.getval(3);                                                                                                                                                           // 3 - zcoord integer
02041                 this -> ycoord = q.getval(4);                                                                                                                                                           // 4 - ycoord integer
02042                 this -> xcoords = q.getstr(5);                                                                                                                                                          // 5 - xcoords text
02043                 new_object = 0;
02044         } else
02045                 clear();
02046         q.free_result();
02047 }
02048 
02049 
02050 void Steps::spawn(Query *qd,int offset)
02051 {
02052         clear();
02053 
02054         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
02055         this -> player = qd -> getval(1 + offset);                                                                                                                                                              // 1 - player integer
02056         this -> area = qd -> getval(2 + offset);                                                                                                                                                                // 2 - area integer
02057         this -> zcoord = qd -> getval(3 + offset);                                                                                                                                                              // 3 - zcoord integer
02058         this -> ycoord = qd -> getval(4 + offset);                                                                                                                                                              // 4 - ycoord integer
02059         this -> xcoords = qd -> getstr(5 + offset);                                                                                                                                                             // 5 - xcoords text
02060 }
02061 
02062 
02063 // End of implementation of class 'Steps'
02064 
02065 } // End of namespace
02066 namespace db {
02067 
02072 Race::Race(Database *db)
02073 {
02074         database = db;
02075         new_object = 1;
02076         clear();
02077 }
02078 
02079 
02080 Race::Race(Database *db,const std::string& sql)
02081 {
02082         database = db;
02083         new_object = 1;
02084         spawn(sql);
02085 }
02086 
02087 
02088 Race::Race(Database *db,Query *qd,int offset)
02089 {
02090         database = db;
02091         new_object = 0;
02092         spawn(qd, offset);
02093 }
02094 
02095 
02096 Race::Race(Database& db,long i_num):database(&db),new_object(1)
02097 {
02098         Query q(*database);
02099         std::string sql = "select * from race where ";
02100         {
02101                 char slask[100];
02102                 sprintf(slask,"num='%ld'",i_num);
02103                 sql += slask;
02104         }
02105         spawn(sql);
02106 }
02107 
02108 
02109 Race::Race(Database& db,const std::string&  i_name):database(&db),new_object(1)
02110 {
02111         Query q(*database);
02112         std::string sql = "select * from race where ";
02113         sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
02114         spawn(sql);
02115 }
02116 
02117 
02118 Race::~Race()
02119 {
02120 }
02121 
02122 
02123 void Race::select(const std::string& sql)
02124 {
02125         spawn(sql);
02126 }
02127 
02128 
02129 unsigned long long int Race::insert()
02130 {
02131         Query q(*database);
02132         std::string sql;
02133 
02134         sql = "insert into race(name,sightrange,hearing)";
02135         sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
02136         {
02137                 char slask[100];
02138                 sprintf(slask,", %f",this -> sightrange);
02139                 sql += slask;
02140         }
02141         {
02142                 char slask[100];
02143                 sprintf(slask,", %f",this -> hearing);
02144                 sql += slask;
02145         }
02146         sql += ")";
02147         q.execute(sql);
02148         new_object = 0;
02149         unsigned long long int inserted_id = q.insert_id();
02150         num = inserted_id;
02151         return inserted_id;
02152 }
02153 
02154 
02155 void Race::update()
02156 {
02157         update(this -> num);
02158 }
02159 
02160 
02161 void Race::update(long i_num)
02162 {
02163         Query q(*database);
02164         std::string sql;
02165         sql += "update race set name='" + q.GetDatabase().safestr(this -> name) + "'";
02166         {
02167                 char slask[200];
02168                 sprintf(slask,", sightrange='%f'",this -> sightrange);
02169                 sql += slask;
02170         }
02171         {
02172                 char slask[200];
02173                 sprintf(slask,", hearing='%f'",this -> hearing);
02174                 sql += slask;
02175         }
02176         {
02177                 char slask[200];
02178                 sprintf(slask," where num='%ld'",i_num);
02179                 sql += slask;
02180         }
02181         q.execute(sql);
02182 }
02183 
02184 
02185 void Race::save()
02186 {
02187         if (new_object)
02188                 insert();
02189         else
02190                 update();
02191 }
02192 
02193 
02194 void Race::erase()
02195 {
02196         if (!new_object)
02197         {
02198                 std::string sql = "delete from race where";
02199                 Query q(*database);
02200                 {
02201                         char slask[200];
02202                         sprintf(slask," num='%ld'",this -> num);
02203                         sql += slask;
02204                 }
02205                 q.execute(sql);
02206         }
02207 }
02208 
02209 
02210 std::string Race::xml()
02211 {
02212         Query q(*database);
02213         std::string dest;
02214         char slask[200];
02215         dest = "<RACE>";
02216         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
02217         dest += slask;
02218         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
02219         sprintf(slask,"<SIGHTRANGE>%f</SIGHTRANGE>",this -> sightrange);
02220         dest += slask;
02221         sprintf(slask,"<HEARING>%f</HEARING>",this -> hearing);
02222         dest += slask;
02223         dest += "</RACE>";
02224         return dest;
02225 }
02226 
02227 
02228 std::string Race::xml(const std::string& tag,const std::string& xvalx)
02229 {
02230         Query q(*database);
02231         std::string dest;
02232         char slask[200];
02233         dest = "<RACE " + tag + "=\"" + xvalx + "\">";
02234         sprintf(slask,"<NUM>%ld</NUM>",this -> num);
02235         dest += slask;
02236         dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
02237         sprintf(slask,"<SIGHTRANGE>%f</SIGHTRANGE>",this -> sightrange);
02238         dest += slask;
02239         sprintf(slask,"<HEARING>%f</HEARING>",this -> hearing);
02240         dest += slask;
02241         dest += "</RACE>";
02242         return dest;
02243 }
02244 
02245 
02246 size_t Race::num_cols()
02247 {
02248         return 4;
02249 }
02250 
02251 
02252 void Race::clear()
02253 {
02254         this -> num = 0;
02255         this -> name = "";
02256         this -> sightrange = 0;
02257         this -> hearing = 0;
02258 }
02259 
02260 
02261 void Race::spawn(const std::string& sql)
02262 {
02263         Query q(*database);
02264         std::string temp;
02265 
02266         clear();
02267 
02268         if (!strncasecmp(sql.c_str(),"select * ",9))
02269         {
02270                 temp = "select num,name,sightrange,hearing " + sql.substr(9);
02271         } else
02272                 temp = sql;
02273         q.get_result(temp);
02274         if (q.fetch_row())
02275         {
02276                 this -> num = q.getval(0);                                                                                                                                                              // 0 - num integer
02277                 this -> name = q.getstr(1);                                                                                                                                                             // 1 - name varchar(255)
02278                 this -> sightrange = q.getnum(2);                                                                                                                                                               // 2 - sightrange float
02279                 this -> hearing = q.getnum(3);                                                                                                                                                          // 3 - hearing float
02280                 new_object = 0;
02281         } else
02282                 clear();
02283         q.free_result();
02284 }
02285 
02286 
02287 void Race::spawn(Query *qd,int offset)
02288 {
02289         clear();
02290 
02291         this -> num = qd -> getval(0 + offset);                                                                                                                                                         // 0 - num integer
02292         this -> name = qd -> getstr(1 + offset);                                                                                                                                                                // 1 - name varchar(255)
02293         this -> sightrange = qd -> getnum(2 + offset);                                                                                                                                                          // 2 - sightrange float
02294         this -> hearing = qd -> getnum(3 + offset);                                                                                                                                                             // 3 - hearing float
02295 }
02296 
02297 
02298 // End of implementation of class 'Race'
02299 
02300 } // End of namespace
Page, code, and content Copyright (C) 2006 by Anders Hedström
Generated on Mon Aug 29 20:21:47 2005 for C++ Sockets by  doxygen 1.4.4