Курсовая по ООП / classes / database

#include "database.h"

DatabaseField::DatabaseField(){
	value=NULL;
	size=0;
}

DatabaseField::DatabaseField(DatabaseField &ex){
	value=malloc(ex.size);
	memcpy(value,ex.value,ex.size);
	size=ex.size;
}

DatabaseField::DatabaseField(DatabaseBody *body,unsigned FieldSize){
	body->Fields.Add(this);
	value=malloc(FieldSize);
	size=FieldSize;
}

DatabaseField& DatabaseField::operator =(DatabaseField &ex) {
	if(this==&ex){
		//if copy thisself
		//nothing to do
	} else {
		if((size!=ex.size)&&size){
			free(value);
			size=ex.size;
			value=malloc(ex.size);
		}
		memcpy(value,ex.value,size);
	}
	return *this;
}

DatabaseField::~DatabaseField(){
	free(value);
	size=0;
}
//----------------------
DatabaseFieldString::DatabaseFieldString(): DatabaseField() {
	//parent do all work 
}

DatabaseFieldString::DatabaseFieldString(DatabaseFieldString &ex): DatabaseField(ex){
	//parent do all work
}

DatabaseFieldString::DatabaseFieldString(DatabaseBody *body, unsigned FieldSize){
	body->Fields.Add(this);
	value=malloc(FieldSize);
	size=FieldSize;
}
DatabaseFieldString::~DatabaseFieldString(){}

char *DatabaseFieldString::Value(void) const {
	return (char*)value;
}

char *DatabaseFieldString::setValue(void) {
	return (char*)value;
}

inline long DatabaseFieldString::ToInt() {
	return atoi((char*)value);
}
char* DatabaseFieldString::ToStr(void){
	return (char*)value;
}
DatabaseField& DatabaseFieldString::operator =(char *str) {
	if(str){
		//if str isn't NULL
		size_t slen=strlen(str)+1;
		memcpy(value,(void*)str,min(slen,size));
	} else {
		//if str is NULL
		strnset((char*)value,0,size);
	}
	return *this;
}
//----------------------
DatabaseBody::DatabaseBody(): 
			  path(NULL), 
			  file(NULL), 
			  Fields(),
			  WS(9),
			  CR('\n'){
	bufsize=100;
	hbuffer=(char *)malloc(sizeof(char)*bufsize);
	lbuffer=(char *)malloc(sizeof(char)*bufsize);
}

DatabaseBody::DatabaseBody(char *p, unsigned bsize,char ws, char cr): 
			  path(NULL), 
			  file(NULL), 
			  Fields(),
			  WS(ws),
			  CR(cr) {
	path=strdup(p);
	bufsize=bsize;
	hbuffer=(char *)malloc(sizeof(char)*bufsize);
	lbuffer=(char *)malloc(sizeof(char)*bufsize);
}

void DatabaseBody::SetPath(char *p){
	if(file)
		Commit();
	if(path)
		free(path);
	p=strdup(p);
}

void DatabaseBody::Launch(short ReadMode) { //ReadWrite
	switch(ReadMode){
		case 2: //Read
			file=fopen(path,"r");
			break;
		case 1: //Rewrite
			file=fopen(path,"w");
			break;
		case 0: //Append
			file=fopen(path,"a+");
			break;
		case 3 :
		default://Read & Write
			file=fopen(path,"r+");
			break;
		
	}
}

void DatabaseBody::Commit() {
	fclose(file);
	file=NULL;
}

DatabaseBody *DatabaseBody::Read(void) {
	//fgets(hbuffer,bufsize-1,file);
	sfread(file,hbuffer,bufsize-1);
	char seps[]={WS,CR,'\0'};
	char *t=strtok(hbuffer,seps);
	unsigned i=1;
	while(t&&(i<=Fields.GetCount())){
		(*Fields[i].value)=t;
		t=strtok(NULL,seps);
		i++;
	}
	strnset(hbuffer,0,bufsize);
	return this;
}

void DatabaseBody::Write(void) {
	strnset(hbuffer,0,bufsize);
	sprintf(hbuffer,"%s",Fields[1].value->ToStr());
	for(unsigned i=2;i<=Fields.GetCount();i++)
		sprintf(hbuffer,"%s%c%s",hbuffer,WS,Fields[i].value->ToStr());
	//unsigned t=strlen(hbuffer);
	//hbuffer[t]=CR;
	fprintf(file,"%s%c",hbuffer,CR);
	//fputs(hbuffer,file);
}

void DatabaseBody::Seek(unsigned pos) {
}

unsigned short DatabaseBody::Ends(){
	return feof(file);
}

DatabaseBody::~DatabaseBody(){
	free(this->hbuffer);
	free(this->lbuffer);
	if(path)
		free(path);
}