C++ MudBase

Terrain::Terrain ( Database * )

Begin class 'Terrain'.

Definition at line 1513 of file libfuture.cpp.

01514 {
01515         database = db;
01516         new_object = 1;
01517         clear();
01518 }

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

Definition at line 1521 of file libfuture.cpp.

01522 {
01523         database = db;
01524         new_object = 1;
01525         spawn(sql);
01526 }

Terrain::Terrain	(	Database *	,
		Query *	,
		int	= `0`
	)

Definition at line 1529 of file libfuture.cpp.

01530 {
01531         database = db;
01532         new_object = 0;
01533         spawn(qd, offset);
01534 }

Terrain::Terrain	(	Database &	,
		long	num
	)

Definition at line 1537 of file libfuture.cpp.

References database, and spawn().

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

Terrain::Terrain	(	Database &	,
		long	area,
		const std::string &	tchar
	)

Definition at line 1550 of file libfuture.cpp.

References database, and spawn().

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

Terrain::~Terrain ( )

Definition at line 1564 of file libfuture.cpp.

01565 {
01566 }

db::Terrain::Terrain ( Database * )

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

db::Terrain::Terrain	(	Database *	,
		Query *	,
		int	= `0`
	)

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

db::Terrain::Terrain	(	Database &	,
		long	area,
		const std::string &	tchar
	)

db::Terrain::~Terrain ( )

Member Function Documentation

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

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

References database.

00292 { return *database; }

unsigned long long int Terrain::insert ( )

Definition at line 1575 of file libfuture.cpp.

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 }

void Terrain::update ( )

Definition at line 1608 of file libfuture.cpp.

01609 {
01610         update(this -> num);
01611 }

void Terrain::save ( )

Definition at line 1645 of file libfuture.cpp.

01646 {
01647         if (new_object)
01648                 insert();
01649         else
01650                 update();
01651 }

void Terrain::erase ( )

Definition at line 1654 of file libfuture.cpp.

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 }

std::string Terrain::xml ( )

Definition at line 1670 of file libfuture.cpp.

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 }

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

Definition at line 1692 of file libfuture.cpp.

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 }

size_t Terrain::num_cols ( )

Definition at line 1714 of file libfuture.cpp.

01715 {
01716         return 7;
01717 }

void Terrain::clear ( ) [private]

Definition at line 1720 of file libfuture.cpp.

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 }

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

Definition at line 1732 of file libfuture.cpp.

Referenced by Terrain().

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 }

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

Definition at line 1761 of file libfuture.cpp.

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 }

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

Definition at line 1569 of file libfuture.cpp.

01570 {
01571         spawn(sql);
01572 }

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

Definition at line 1614 of file libfuture.cpp.

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 }

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

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

References database.

00292 { return *database; }

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

void db::Terrain::update ( )

void db::Terrain::save ( )

void db::Terrain::erase ( )

std::string db::Terrain::xml ( )

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

size_t db::Terrain::num_cols ( )

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

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

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

db::Terrain Class Reference

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation