RSS

SQLite3クラス

22 11月

SQLite.h

#ifndef CURS_FWX_SQLITE
#define CURS_FWX_SQLITE
#include <string.h>
#include <stdio.h>
#include <sqlite3.h>
#include "Object.h"

namespace curfwx
{

class SQLite : Object
{
public: class Reader : Object
{
public:
 sqlite3_stmt* pStmt;

public:
 int result;
 Reader(const char* command, sqlite3* db);
 ~Reader();

 void close();
 int getFieldCount();
 bool read();
 int getString(int n, char* buf, int len);
 int getInteger(int n);
};

/* definition of SQLite class */
protected:
 bool f_init;
 bool f_connect;
 char filename[512];
 sqlite3* pDb;
 Reader* reader;

public:
 SQLite(const char* path);
 virtual ~SQLite();

 bool open();
 void close();
 int query(const char* command);
 int execute(const char* command);
 Reader* getReader() { return this->reader; }
};
}
#endif

SQLite.cpp

/************************************************************

 SQLite class (SQLite.cpp)

 ***********************************************************/
#include "include/SQLite.h"

using namespace curfwx;

/* constructor of SQLite class */
SQLite::SQLite(const char* path) : Object("curfwx.SQLite")
{
 this->f_init = false;
 this->f_connect = false;
 if (strlen(path) > sizeof(this->filename) - 1)
 return;

 strcpy(this->filename, path);
 this->f_init = true;
 pDb = NULL;
}

/* destructor */
SQLite::~SQLite()
{
 if (f_connect)
 this->close();
}

/* connect to sqlite3 */
bool::SQLite::open()
{
 if (!f_init)
 return false;

 f_connect = false;
 if (sqlite3_open(this->filename, &(this->pDb)) == SQLITE_OK)
 f_connect = true;

 return f_connect;
}

/* disconnect from sqlite3 */
void SQLite::close()
{
 if (!f_connect)
 return;

 sqlite3_close(this->pDb);
 f_connect = false;
}

int SQLite::query(const char* command)
{
 if (!f_connect)
 return -1;

 this->reader = new SQLite::Reader(command, this->pDb);
 return 0;
}

int SQLite::execute(const char* command)
{
 return sqlite3_exec(this->pDb, command, NULL, NULL, NULL);
}

/*  Reader sub class */
SQLite::Reader::Reader(const char* command, sqlite3* db) : Object("curfwx.SQLite.Reader")
{
 this->pStmt = NULL;
 result = sqlite3_prepare(db, command, strlen(command), &(this->pStmt), NULL);
 sqlite3_reset(this->pStmt);
}

SQLite::Reader::~Reader()
{
 this->close();
}

void SQLite::Reader::close()
{
 if (this->pStmt != NULL)
 {
 sqlite3_finalize(this->pStmt);
 this->pStmt = NULL;
 }
}

int SQLite::Reader::getFieldCount()
{
 if (this->pStmt == NULL)
 return 0;

 return sqlite3_column_count(this->pStmt);
}

bool SQLite::Reader::read()
{
 if (this->pStmt == NULL)
 return false;

 return (sqlite3_step(this->pStmt) != SQLITE_DONE);
}

int SQLite::Reader::getString(int n, char* buf, int len)
{
 const unsigned char* p = sqlite3_column_text(this->pStmt, n);
 strncpy(buf, (const char*)p, len);
 int r = strlen(buf);
 return r;
}

int SQLite::Reader::getInteger(int n)
{
 return sqlite3_column_int(this->pStmt, n);
}

Object.h

#ifndef CURS_FWX_OBJECT
#define CURS_FWX_OBJECT
/*  Object class of curses frame work */
/*     Object.h     */
#include <string>
#include <fstream>
#include <string.h>

namespace curfwx
{
class Object
{
protected:
 int ref_count;

public:
 std::string name;

 /* constructor(s) */
 Object(){
 this->name = "curfwx.Object";
 this->ref_count = 1;
 }

 Object(const char* name){
 if (name != NULL)
 this->name = name;
 else
 this->name = "curfwx.Object";

 this->ref_count = 1;
 }

 /* destructor */
 ~Object(){ this->ref_count = 0; }

 /* methods */
 virtual std::string toString() { return this->name; }
 virtual void operator << (std::ofstream& ofs)
 { ofs << this->name << this->ref_count; }
 virtual void operator >> (std::ifstream& ifs)
 { ifs >> this->name >> this->ref_count; }

 int addRef();
 int release();
 int getRefCount() { return this->ref_count; }
 virtual unsigned long getHash();
 static unsigned long getCRC32(
 unsigned const char* buff, 
 size_t size);
 virtual Object* dup();
 virtual bool operator == (Object& a);
 virtual Object& operator = (Object& a);
};
}
#endif

Object.cpp

#include <limits.h>  // CHAR_BIT
#include "include/Object.h"

using namespace curfwx;

int Object::addRef()
{
 this->ref_count++; 
 return this->ref_count;
}

int Object::release()
{
 if (this->ref_count > 0)
 this->ref_count--;
 return this->ref_count;
}

unsigned long Object::getHash()
{
 return Object::getCRC32((const unsigned char*)this, sizeof(this));
}

Object* Object::dup()
{
 Object* p = new Object();
 p->name = this->name;
 p->ref_count = this->ref_count + 1;
 return p;
}

bool Object::operator == (Object& a)
{
 return (this->ref_count == a.ref_count && this->name == a.name);
}

Object& Object::operator = (Object& a) 
{
 this->name = a.name;
 this->ref_count = a.ref_count;
}
 
コメントする

投稿者: : 2010/11/22 投稿先 C

 

タグ:

コメントを残す

以下に詳細を記入するか、アイコンをクリックしてログインしてください。

WordPress.com ロゴ

WordPress.com アカウントを使ってコメントしています。 ログアウト / 変更 )

Twitter 画像

Twitter アカウントを使ってコメントしています。 ログアウト / 変更 )

Facebook の写真

Facebook アカウントを使ってコメントしています。 ログアウト / 変更 )

Google+ フォト

Google+ アカウントを使ってコメントしています。 ログアウト / 変更 )

%s と連携中