Logo
Search Site
~Sockets~
 C++ Sockets 
 Tutorial 
 Classes 
 License 
 Java Sockets 
~Examples~
 SMTPProxy 
 PortProxy 
 ChatServer 
 ClientServer 
 HttpGet 
 DChat 
 WebServer 
 UDP 
 ICMP 
 Small MUD 
 MudBase 
~Contact~
message board
 email author 
db::Chunkinfo

db::Chunkinfo Class Reference

#include <libfuture.h>

Collaboration diagram for db::Chunkinfo:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 Chunkinfo (Database *)
 Begin class 'Chunkinfo'.
 Chunkinfo (Database *, const std::string &)
 Chunkinfo (Database *, Query *, int=0)
 Chunkinfo (Database &, long num)
 Chunkinfo (Database &, long chunk, long type, long x, long y)
 ~Chunkinfo ()
Database & GetDatabase ()
unsigned long long int insert ()
void update ()
void save ()
void erase ()
std::string xml ()
std::string xml (const std::string &, const std::string &)
size_t num_cols ()
 Chunkinfo (Database *)
 Chunkinfo (Database *, const std::string &)
 Chunkinfo (Database *, Query *, int=0)
 Chunkinfo (Database &, long num)
 Chunkinfo (Database &, long chunk, long type, long x, long y)
 ~Chunkinfo ()
Database & GetDatabase ()
unsigned long long int insert ()
void update ()
void save ()
void erase ()
std::string xml ()
std::string xml (const std::string &, const std::string &)
size_t num_cols ()

Public Attributes

long num
long chunk
long type
long x
long y
std::string data
long to_area
long to_chunk
long to_x
long to_y

Private Member Functions

void clear ()
void spawn (const std::string &)
void spawn (Query *, int=0)
void select (const std::string &)
void update (long num)
void clear ()
void spawn (const std::string &)
void spawn (Query *, int=0)
void select (const std::string &)
void update (long num)

Private Attributes

Database * database
short new_object
Database * database

Detailed Description

Definition at line 235 of file root/src/futuremud/libfuture/libfuture.h.

Constructor & Destructor Documentation

Chunkinfo::Chunkinfo ( Database *   ) 

Begin class 'Chunkinfo'.

Definition at line 1157 of file libfuture.cpp.

01158 {
01159         database = db;
01160         new_object = 1;
01161         clear();
01162 }

Chunkinfo::Chunkinfo ( Database *  ,
const std::string &   
)

Definition at line 1165 of file libfuture.cpp.

01166 {
01167         database = db;
01168         new_object = 1;
01169         spawn(sql);
01170 }

Chunkinfo::Chunkinfo ( Database *  ,
Query *  ,
int  = 0 
)

Definition at line 1173 of file libfuture.cpp.

01174 {
01175         database = db;
01176         new_object = 0;
01177         spawn(qd, offset);
01178 }

Chunkinfo::Chunkinfo ( Database &  ,
long  num 
)

Definition at line 1181 of file libfuture.cpp.

References database, and spawn().

01181                                            :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 }

Chunkinfo::Chunkinfo ( Database &  ,
long  chunk,
long  type,
long  x,
long  y 
)

Definition at line 1194 of file libfuture.cpp.

References database, and spawn().

01194                                                                            :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 }

Chunkinfo::~Chunkinfo (  ) 

Definition at line 1222 of file libfuture.cpp.

01223 {
01224 }

db::Chunkinfo::Chunkinfo ( Database *   ) 

db::Chunkinfo::Chunkinfo ( Database *  ,
const std::string &   
)

db::Chunkinfo::Chunkinfo ( Database *  ,
Query *  ,
int  = 0 
)

db::Chunkinfo::Chunkinfo ( Database &  ,
long  num 
)

db::Chunkinfo::Chunkinfo ( Database &  ,
long  chunk,
long  type,
long  x,
long  y 
)

db::Chunkinfo::~Chunkinfo (  ) 

Member Function Documentation

Database& db::Chunkinfo::GetDatabase (  )  [inline]

Definition at line 243 of file root/src/futuremud/libfuture/libfuture.h.

References database.

00243 { return *database; }

unsigned long long int Chunkinfo::insert (  ) 

Definition at line 1233 of file libfuture.cpp.

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 }

void Chunkinfo::update (  ) 

Definition at line 1289 of file libfuture.cpp.

01290 {
01291         update(this -> num);
01292 }

void Chunkinfo::save (  ) 

Definition at line 1349 of file libfuture.cpp.

01350 {
01351         if (new_object)
01352                 insert();
01353         else
01354                 update();
01355 }

void Chunkinfo::erase (  ) 

Definition at line 1358 of file libfuture.cpp.

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 }

std::string Chunkinfo::xml (  ) 

Definition at line 1374 of file libfuture.cpp.

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 }

std::string Chunkinfo::xml ( const std::string &  ,
const std::string &   
)

Definition at line 1404 of file libfuture.cpp.

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 }

size_t Chunkinfo::num_cols (  ) 

Definition at line 1434 of file libfuture.cpp.

01435 {
01436         return 10;
01437 }

void Chunkinfo::clear (  )  [private]

Definition at line 1440 of file libfuture.cpp.

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 }

void Chunkinfo::spawn ( const std::string &   )  [private]

Definition at line 1455 of file libfuture.cpp.

Referenced by Chunkinfo().

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 }

void Chunkinfo::spawn ( Query *  ,
int  = 0 
) [private]

Definition at line 1487 of file libfuture.cpp.

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 }

void Chunkinfo::select ( const std::string &   )  [private]

Definition at line 1227 of file libfuture.cpp.

01228 {
01229         spawn(sql);
01230 }

void Chunkinfo::update ( long  num  )  [private]

Definition at line 1295 of file libfuture.cpp.

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 }

Database& db::Chunkinfo::GetDatabase (  )  [inline]

Definition at line 243 of file usr/devel/include/libfuture.h.

References database.

00243 { return *database; }

unsigned long long int db::Chunkinfo::insert (  ) 

void db::Chunkinfo::update (  ) 

void db::Chunkinfo::save (  ) 

void db::Chunkinfo::erase (  ) 

std::string db::Chunkinfo::xml (  ) 

std::string db::Chunkinfo::xml ( const std::string &  ,
const std::string &   
)

size_t db::Chunkinfo::num_cols (  ) 

void db::Chunkinfo::clear (  )  [private]

void db::Chunkinfo::spawn ( const std::string &   )  [private]

void db::Chunkinfo::spawn ( Query *  ,
int  = 0 
) [private]

void db::Chunkinfo::select ( const std::string &   )  [private]

void db::Chunkinfo::update ( long  num  )  [private]

Member Data Documentation

long Chunkinfo::num

Definition at line 254 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::chunk

Definition at line 255 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::type

Definition at line 256 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::x

Definition at line 257 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::y

Definition at line 258 of file root/src/futuremud/libfuture/libfuture.h.

std::string Chunkinfo::data

Definition at line 259 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::to_area

Definition at line 260 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::to_chunk

Definition at line 261 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::to_x

Definition at line 262 of file root/src/futuremud/libfuture/libfuture.h.

long Chunkinfo::to_y

Definition at line 263 of file root/src/futuremud/libfuture/libfuture.h.

Database* db::Chunkinfo::database [private]

Definition at line 272 of file root/src/futuremud/libfuture/libfuture.h.

Referenced by Chunkinfo(), and GetDatabase().

short Chunkinfo::new_object [private]

Definition at line 273 of file root/src/futuremud/libfuture/libfuture.h.

Database* db::Chunkinfo::database [private]

Definition at line 272 of file usr/devel/include/libfuture.h.

The documentation for this class was generated from the following files:
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