DBCFileLoader Class Reference

#include <DBCFileLoader.h>

Classes
class	Record

Public Member Functions
	DBCFileLoader ()
	~DBCFileLoader ()
bool	Load (const char *filename, const char *fmt)
Record	getRecord (size_t id)
uint32	GetNumRows () const
	Get begin iterator over records. More...
uint32	GetRowSize () const
uint32	GetCols () const
uint32	GetOffset (size_t id) const
bool	IsLoaded () const
char *	AutoProduceData (const char *fmt, uint32 &count, char **&indexTable, uint32 sqlRecordCount, uint32 sqlHighestIndex, char *&sqlDataTable)
char *	AutoProduceStrings (const char *fmt, char *dataTable)

Static Public Member Functions
static uint32	GetFormatRecordSize (const char *format, int32 *index_pos=NULL)

Private Member Functions
	DBCFileLoader (DBCFileLoader const &right)=delete
DBCFileLoader &	operator= (DBCFileLoader const &right)=delete

Private Attributes
uint32	recordSize
uint32	recordCount
uint32	fieldCount
uint32	stringSize
uint32 *	fieldsOffset
unsigned char *	data
unsigned char *	stringTable

Constructor & Destructor Documentation

DBCFileLoader::DBCFileLoader

(

)

: recordSize(0), recordCount(0), fieldCount(0), stringSize(0), fieldsOffset(NULL), data(NULL), stringTable(NULL) { }

DBCFileLoader::~DBCFileLoader

(

)

{
 delete[] data;

 delete[] fieldsOffset;
}

DBCFileLoader::DBCFileLoader ( DBCFileLoader const &  right )

privatedelete

Member Function Documentation

char * DBCFileLoader::AutoProduceData	(	const char *	fmt,
		uint32 &	count,
		char **&	indexTable,
		uint32	sqlRecordCount,
		uint32	sqlHighestIndex,
		char *&	sqlDataTable
	)

{
 /*
 format STRING, NA, FLOAT, NA, INT <=>
 struct{
 char* field0,
 float field1,
 int field2
 }entry;

 this func will generate entry[rows] data;
 */

 typedef char* ptr;
 if (strlen(format) != fieldCount)
 return NULL;

 //get struct size and index pos
 int32 i;
 uint32 recordsize = GetFormatRecordSize(format, &i);

 if (i >= 0)
 {
 uint32 maxi = 0;
 //find max index
 for (uint32 y = 0; y < recordCount; ++y)
 {
 uint32 ind = getRecord(y).getUInt(i);
 if (ind > maxi)
 maxi = ind;
 }

 // If higher index avalible from sql - use it instead of dbcs
 if (sqlHighestIndex > maxi)
 maxi = sqlHighestIndex;

 ++maxi;
 records = maxi;
 indexTable = new ptr[maxi];
 memset(indexTable, 0, maxi * sizeof(ptr));
 }
 else
 {
 records = recordCount + sqlRecordCount;
 indexTable = new ptr[recordCount + sqlRecordCount];
 }

 char* dataTable = new char[(recordCount + sqlRecordCount) * recordsize];

 uint32 offset = 0;

 for (uint32 y = 0; y < recordCount; ++y)
 {
 if (i >= 0)
 indexTable[getRecord(y).getUInt(i)] = &dataTable[offset];
 else
 indexTable[y] = &dataTable[offset];

 for (uint32 x=0; x < fieldCount; ++x)
 {
 switch (format[x])
 {
 case FT_FLOAT:
 *((float*)(&dataTable[offset])) = getRecord(y).getFloat(x);
 offset += sizeof(float);
 break;
 case FT_IND:
 case FT_INT:
 *((uint32*)(&dataTable[offset])) = getRecord(y).getUInt(x);
 offset += sizeof(uint32);
 break;
 case FT_BYTE:
 *((uint8*)(&dataTable[offset])) = getRecord(y).getUInt8(x);
 offset += sizeof(uint8);
 break;
 case FT_LONG:
 *((uint64*)(&dataTable[offset])) = getRecord(y).getUInt64(x);
 offset += sizeof(uint64);
 break;
 case FT_STRING:
 *((char**)(&dataTable[offset])) = NULL; // will replace non-empty or "" strings in AutoProduceStrings
 offset += sizeof(char*);
 break;
 case FT_NA:
 case FT_NA_BYTE:
 case FT_SORT:
 break;
 default:
 ASSERT(false && "Unknown field format character in DBCfmt.h");
 break;
 }
 }
 }

 sqlDataTable = dataTable + offset;

 return dataTable;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * DBCFileLoader::AutoProduceStrings	(	const char *	fmt,
		char *	dataTable
	)

{
 if (strlen(format) != fieldCount)
 return NULL;

 char* stringPool = new char[stringSize];
 memcpy(stringPool, stringTable, stringSize);

 uint32 offset = 0;

 for (uint32 y = 0; y < recordCount; ++y)
 {
 for (uint32 x = 0; x < fieldCount; ++x)
 {
 switch (format[x])
 {
 case FT_FLOAT:
 offset += sizeof(float);
 break;
 case FT_IND:
 case FT_INT:
 offset += sizeof(uint32);
 break;
 case FT_BYTE:
 offset += sizeof(uint8);
 break;
 case FT_LONG:
 offset += sizeof(uint64);
 break;
 case FT_STRING:
 {
 // fill only not filled entries
 char** slot = (char**)(&dataTable[offset]);
 if (!*slot || !**slot)
 {
 const char * st = getRecord(y).getString(x);
 *slot=stringPool+(st-(const char*)stringTable);
 }
 offset += sizeof(char*);
 break;
 }
 case FT_NA:
 case FT_NA_BYTE:
 case FT_SORT:
 break;
 default:
 ASSERT(false && "Unknown field format character in DBCfmt.h");
 break;
 }
 }
 }

 return stringPool;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 DBCFileLoader::GetCols ( ) const

inline

{ return fieldCount; }

Here is the caller graph for this function:

uint32 DBCFileLoader::GetFormatRecordSize ( const char *  format, int32 *  index_pos = NULL  )

static

{
 uint32 recordsize = 0;
 int32 i = -1;
 for (uint32 x = 0; format[x]; ++x)
 {
 switch (format[x])
 {
 case FT_FLOAT:
 recordsize += sizeof(float);
 break;
 case FT_INT:
 recordsize += sizeof(uint32);
 break;
 case FT_STRING:
 recordsize += sizeof(char*);
 break;
 case FT_SORT:
 i = x;
 break;
 case FT_IND:
 i = x;
 recordsize += sizeof(uint32);
 break;
 case FT_BYTE:
 recordsize += sizeof(uint8);
 break;
 case FT_LONG:
 recordsize += sizeof(uint64);
 break;
 case FT_NA:
 case FT_NA_BYTE:
 break;
 default:
 ASSERT(false && "Unknown field format character in DBCfmt.h");
 break;
 }
 }

 if (index_pos)
 *index_pos = i;

 return recordsize;
}

Here is the caller graph for this function:

uint32 DBCFileLoader::GetNumRows ( ) const

inline

Get begin iterator over records.

{ return recordCount; }

Here is the caller graph for this function:

uint32 DBCFileLoader::GetOffset ( size_t  id ) const

inline

{ return (fieldsOffset != NULL && id < fieldCount) ? fieldsOffset[id] : 0; }

DBCFileLoader::Record DBCFileLoader::getRecord

(

size_t

id

)

{
 assert(data);
 return Record(*this, data + id * recordSize);
}

Here is the caller graph for this function:

uint32 DBCFileLoader::GetRowSize ( ) const

inline

{ return recordSize; }

bool DBCFileLoader::IsLoaded ( ) const

inline

{ return data != NULL; }

bool DBCFileLoader::Load	(	const char *	filename,
		const char *	fmt
	)

{
 uint32 header;
 if (data)
 {
 delete [] data;
 data = NULL;
 }

 FILE* f = fopen(filename, "rb");
 if (!f)
 return false;

 if (fread(&header, 4, 1, f) != 1) // Number of records
 {
 fclose(f);
 return false;
 }


 EndianConvert(header);

 if (header != 0x43424457) //'WDBC'
 {
 fclose(f);
 return false;
 }

 if (fread(&recordCount, 4, 1, f) != 1) // Number of records
 {
 fclose(f);
 return false;
 }

 EndianConvert(recordCount);

 if (fread(&fieldCount, 4, 1, f) != 1) // Number of fields
 {
 fclose(f);
 return false;
 }

 EndianConvert(fieldCount);

 if (fread(&recordSize, 4, 1, f) != 1) // Size of a record
 {
 fclose(f);
 return false;
 }

 EndianConvert(recordSize);

 if (fread(&stringSize, 4, 1, f) != 1) // String size
 {
 fclose(f);
 return false;
 }

 EndianConvert(stringSize);

 fieldsOffset = new uint32[fieldCount];
 fieldsOffset[0] = 0;
 for (uint32 i = 1; i < fieldCount; ++i)
 {
 fieldsOffset[i] = fieldsOffset[i - 1];
 if (fmt[i - 1] == FT_BYTE || fmt[i - 1] == FT_NA_BYTE) // byte fields
 fieldsOffset[i] += sizeof(uint8);
 else if (fmt[i - 1] == FT_LONG)
 fieldsOffset[i] += sizeof(uint64);
 else // 4 byte fields (int32/float/strings)
 fieldsOffset[i] += sizeof(uint32);
 }

 data = new unsigned char[recordSize * recordCount + stringSize];
 stringTable = data + recordSize*recordCount;

 if (fread(data, recordSize * recordCount + stringSize, 1, f) != 1)
 {
 fclose(f);
 return false;
 }

 fclose(f);

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DBCFileLoader& DBCFileLoader::operator= ( DBCFileLoader const &  right )

privatedelete

Member Data Documentation

unsigned char* DBCFileLoader::data

private

uint32 DBCFileLoader::fieldCount

private

uint32* DBCFileLoader::fieldsOffset

private

uint32 DBCFileLoader::recordCount

private

uint32 DBCFileLoader::recordSize

private

uint32 DBCFileLoader::stringSize

private

unsigned char* DBCFileLoader::stringTable

private

---

The documentation for this class was generated from the following files:

• src/server/shared/DataStores/DBCFileLoader.h
• src/server/shared/DataStores/DBCFileLoader.cpp