DB2FileLoader Class Reference

#include <DB2StorageLoader.h>

Classes
class	Record

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

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

Private Attributes
char const *	fileName
uint32	recordSize
uint32	recordCount
uint32	fieldCount
uint32	stringSize
uint32 *	fieldsOffset
unsigned char *	data
unsigned char *	stringTable
uint32	tableHash
uint32	build
int	unk1
int	minIndex
int	maxIndex
int	localeMask
int	unk5

Constructor & Destructor Documentation

DB2FileLoader::DB2FileLoader

(

)

{
 fileName = nullptr;
 recordSize = 0;
 recordCount = 0;
 fieldCount = 0;
 stringSize = 0;
 fieldsOffset = nullptr;
 data = nullptr;
 stringTable = nullptr;

 tableHash = 0;
 build = 0;

 unk1 = 0;
 minIndex = 0;
 maxIndex = 0;
 localeMask = 0;
 unk5 = 0;
}

DB2FileLoader::~DB2FileLoader

(

)

{
 if (data)
 delete [] data;
 if (fieldsOffset)
 delete [] fieldsOffset;
}

Member Function Documentation

char * DB2FileLoader::AutoProduceData	(	const char *	fmt,
		uint32 &	count,
		char **&	indexTable
	)

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

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

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

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

 char* dataTable = new char[recordCount * recordsize];

 uint32 offset = 0;

 for (uint32 y = 0; y < recordCount; y++)
 {
 if (indexField >= 0)
 indexTable[getRecord(y).getUInt(indexField)] = &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 += 4;
 break;
 case FT_IND:
 case FT_INT:
 *((uint32*)(&dataTable[offset])) = getRecord(y).getUInt(x);
 offset += 4;
 break;
 case FT_BYTE:
 *((uint8*)(&dataTable[offset])) = getRecord(y).getUInt8(x);
 offset += 1;
 break;
 case FT_LONG:
 *((uint64*)(&dataTable[offset])) = getRecord(y).getUInt64(x);
 offset += 8;
 break;
 case FT_STRING:
 case FT_STRING_NOT_LOCALIZED:
 *((char**)(&dataTable[offset])) = nullptr; // will be replaces non-empty or "" strings in AutoProduceStrings
 offset += sizeof(char*);
 break;
 }
 }
 }

 return dataTable;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * DB2FileLoader::AutoProduceStrings	(	const char *	fmt,
		char *	dataTable,
		uint32	locale
	)

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

 if (!(localeMask & (1 << locale)))
 {
 char const* sep = "";
 std::ostringstream str;
 for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
 {
 if (localeMask & (1 << i))
 {
 str << sep << localeNames[i];
 sep = ", ";
 }
 }

 TC_LOG_ERROR("", "Attempted to load %s which has locales %s as %s. Check if you placed your localized db2 files in correct directory.", fileName, str.str().c_str(), localeNames[locale]);
 return nullptr;
 }

 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:
 case FT_IND:
 case FT_INT:
 offset += 4;
 break;
 case FT_BYTE:
 offset += 1;
 break;
 case FT_LONG:
 offset += 8;
 break;
 case FT_STRING:
 {
 // fill only not filled entries
 LocalizedString* db2str = *(LocalizedString**)(&dataTable[offset]);
 if (db2str->Str[locale] == nullStr)
 {
 char const* st = getRecord(y).getString(x);
 db2str->Str[locale] = stringPool + (st - (char const*)stringTable);
 }

 offset += sizeof(char*);
 break;
 }
 case FT_STRING_NOT_LOCALIZED:
 {
 char** db2str = (char**)(&dataTable[offset]);
 char const* st = getRecord(y).getString(x);
 *db2str = stringPool + (st - (char const*)stringTable);
 offset += sizeof(char*);
 break;
 }
 }
 }
 }

 return stringPool;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * DB2FileLoader::AutoProduceStringsArrayHolders	(	const char *	fmt,
		char *	dataTable
	)

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

 // we store flat holders pool as single memory block
 std::size_t stringFields = GetFormatStringFieldCount(format);
 if (!stringFields)
 return nullptr;

 std::size_t localizedStringFields = GetFormatLocalizedStringFieldCount(format);

 // each string field at load have array of string for each locale
 std::size_t stringHolderSize = sizeof(char*) * TOTAL_LOCALES;
 std::size_t stringHoldersRecordPoolSize = localizedStringFields * stringHolderSize + (stringFields - localizedStringFields) * sizeof(char*);
 std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * recordCount;

 char* stringHoldersPool = new char[stringHoldersPoolSize];

 // DB2 strings expected to have at least empty string
 for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i)
 ((char const**)stringHoldersPool)[i] = nullStr;

 uint32 offset = 0;

 // assign string holders to string field slots
 for (uint32 y = 0; y < recordCount; y++)
 {
 uint32 stringFieldOffset = 0;

 for (uint32 x = 0; x < fieldCount; x++)
 {
 switch (format[x])
 {
 case FT_FLOAT:
 case FT_IND:
 case FT_INT:
 offset += 4;
 break;
 case FT_BYTE:
 offset += 1;
 break;
 case FT_LONG:
 offset += 8;
 break;
 case FT_STRING:
 case FT_STRING_NOT_LOCALIZED:
 {
 // init db2 string field slots by pointers to string holders
 char const*** slot = (char const***)(&dataTable[offset]);
 *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * y + stringFieldOffset]);
 if (format[x] == FT_STRING)
 stringFieldOffset += stringHolderSize;
 else
 ++stringFieldOffset;

 offset += sizeof(char*);
 break;
 }
 default:
 ASSERT(false, "unknown format character %c", format[x]);
 }
 }
 }

 //send as char* for store in char* pool list for free at unload
 return stringHoldersPool;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 DB2FileLoader::GetCols ( ) const

inline

{ return fieldCount; }

Here is the caller graph for this function:

uint32 DB2FileLoader::GetFormatLocalizedStringFieldCount ( const char *  format )

static

{
 uint32 stringfields = 0;
 for (uint32 x = 0; format[x]; ++x)
 if (format[x] == FT_STRING)
 ++stringfields;

 return stringfields;
}

Here is the caller graph for this function:

uint32 DB2FileLoader::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:
 case FT_INT:
 recordsize += 4;
 break;
 case FT_STRING:
 case FT_STRING_NOT_LOCALIZED:
 recordsize += sizeof(char*);
 break;
 case FT_SORT:
 i = x;
 break;
 case FT_IND:
 i = x;
 recordsize += 4;
 break;
 case FT_BYTE:
 recordsize += 1;
 break;
 case FT_LONG:
 recordsize += 8;
 break;
 }
 }

 if (index_pos)
 *index_pos = i;

 return recordsize;
}

Here is the caller graph for this function:

uint32 DB2FileLoader::GetFormatStringFieldCount ( const char *  format )

static

{
 uint32 stringfields = 0;
 for (uint32 x = 0; format[x]; ++x)
 if (format[x] == FT_STRING || format[x] == FT_STRING_NOT_LOCALIZED)
 ++stringfields;

 return stringfields;
}

Here is the caller graph for this function:

uint32 DB2FileLoader::GetHash ( ) const

inline

{ return tableHash; }

Here is the caller graph for this function:

uint32 DB2FileLoader::GetNumRows ( ) const

inline

Get begin iterator over records.

{ return recordCount;}

uint32 DB2FileLoader::GetOffset ( size_t  id ) const

inline

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

DB2FileLoader::Record DB2FileLoader::getRecord

(

size_t

id

)

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

Here is the caller graph for this function:

bool DB2FileLoader::IsLoaded ( ) const

inline

{ return (data != NULL); }

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

{
 if (data)
 {
 delete[] data;
 data = nullptr;
 }

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

 fileName = filename;
 uint32 header;
 if (fread(&header, 4, 1, f) != 1) // Signature
 {
 fclose(f);
 return false;
 }

 EndianConvert(header);

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

 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);

 /* NEW WDB2 FIELDS*/
 if (fread(&tableHash, 4, 1, f) != 1) // Table hash
 {
 fclose(f);
 return false;
 }

 EndianConvert(tableHash);

 if (fread(&build, 4, 1, f) != 1) // Build
 {
 fclose(f);
 return false;
 }

 EndianConvert(build);

 if (fread(&unk1, 4, 1, f) != 1) // Unknown WDB2
 {
 fclose(f);
 return false;
 }

 EndianConvert(unk1);

 if (fread(&minIndex, 4, 1, f) != 1) // MinIndex WDB2
 {
 fclose(f);
 return false;
 }

 EndianConvert(minIndex);

 if (fread(&maxIndex, 4, 1, f) != 1) // MaxIndex WDB2
 {
 fclose(f);
 return false;
 }

 EndianConvert(maxIndex);

 if (fread(&localeMask, 4, 1, f) != 1) // Locales
 {
 fclose(f);
 return false;
 }

 EndianConvert(localeMask);

 if (fread(&unk5, 4, 1, f) != 1) // Unknown WDB2
 {
 fclose(f);
 return false;
 }

 EndianConvert(unk5);

 if (maxIndex != 0)
 {
 int32 diff = maxIndex - minIndex + 1;
 fseek(f, diff * 4 + diff * 2, SEEK_CUR); // diff * 4: an index for rows, diff * 2: a memory allocation bank
 }

 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) // byte fields
 fieldsOffset[i] += 1;
 else if (fmt[i - 1] == FT_LONG)
 fieldsOffset[i] += 8;
 else // 4 byte fields (int32/float/strings)
 fieldsOffset[i] += 4;
 }

 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:

Member Data Documentation

uint32 DB2FileLoader::build

private

unsigned char* DB2FileLoader::data

private

uint32 DB2FileLoader::fieldCount

private

uint32* DB2FileLoader::fieldsOffset

private

char const* DB2FileLoader::fileName

private

int DB2FileLoader::localeMask

private

int DB2FileLoader::maxIndex

private

int DB2FileLoader::minIndex

private

uint32 DB2FileLoader::recordCount

private

uint32 DB2FileLoader::recordSize

private

uint32 DB2FileLoader::stringSize

private

unsigned char* DB2FileLoader::stringTable

private

uint32 DB2FileLoader::tableHash

private

int DB2FileLoader::unk1

private

int DB2FileLoader::unk5

private

---

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

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