DBCFileLoader Class Reference

#include "DBCFileLoader.h"

Classes
class	Record

Public Member Functions
	DBCFileLoader ()
	~DBCFileLoader ()
bool	Load (const char *filename, const char *fmt)
Record	getRecord (std::size_t id)
uint32	GetNumRows () const
uint32	GetRowSize () const
uint32	GetCols () const
uint32	GetOffset (std::size_t id) const
bool	IsLoaded () const
char *	AutoProduceData (char const *fmt, uint32 &count, char **&indexTable)
char *	AutoProduceStrings (char const *fmt, char *dataTable)

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

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

Detailed Description

Constructor & Destructor Documentation

DBCFileLoader() [1/2]

DBCFileLoader::DBCFileLoader

(

)

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

~DBCFileLoader()

DBCFileLoader::~DBCFileLoader

(

)

{
    delete[] data;
 
    delete[] fieldsOffset;
}

References data, and fieldsOffset.

DBCFileLoader() [2/2]

DBCFileLoader::DBCFileLoader ( DBCFileLoader const &  right )

privatedelete

Member Function Documentation

AutoProduceData()

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

{
    /*
    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 nullptr;
    }
 
    //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;
            }
        }
 
        ++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 (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_STRING:
                    *((char**)(&dataTable[offset])) = nullptr;   // will replace non-empty or "" strings in AutoProduceStrings
                    offset += sizeof(char*);
                    break;
                case FT_LOGIC:
                    ASSERT(false && "Attempted to load DBC files that do not have field types that match what is in the core. Check DBCfmt.h or your DBC files.");
                    break;
                case FT_NA:
                case FT_NA_BYTE:
                case FT_SORT:
                    break;
                default:
                    ASSERT(false && "Unknown field format character in DBCfmt.h");
                    break;
            }
        }
    }
 
    return dataTable;
}

References ASSERT, fieldCount, FT_BYTE, FT_FLOAT, FT_IND, FT_INT, FT_LOGIC, FT_NA, FT_NA_BYTE, FT_SORT, FT_STRING, DBCFileLoader::Record::getFloat(), GetFormatRecordSize(), getRecord(), DBCFileLoader::Record::getUInt(), DBCFileLoader::Record::getUInt8(), and recordCount.

Referenced by DBCStorageBase::Load().

AutoProduceStrings()

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

{
    if (strlen(format) != fieldCount)
    {
        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:
                    offset += sizeof(float);
                    break;
                case FT_IND:
                case FT_INT:
                    offset += sizeof(uint32);
                    break;
                case FT_BYTE:
                    offset += sizeof(uint8);
                    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 - (char const*)stringTable);
                    }
                    offset += sizeof(char*);
                    break;
                }
                case FT_LOGIC:
                    ASSERT(false && "Attempted to load DBC files that does not have field types that match what is in the core. Check DBCfmt.h or your DBC files.");
                    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;
}

References ASSERT, fieldCount, FT_BYTE, FT_FLOAT, FT_IND, FT_INT, FT_LOGIC, FT_NA, FT_NA_BYTE, FT_SORT, FT_STRING, getRecord(), DBCFileLoader::Record::getString(), recordCount, stringSize, and stringTable.

Referenced by DBCStorageBase::Load(), and DBCStorageBase::LoadStringsFrom().

GetCols()

uint32 DBCFileLoader::GetCols ( ) const

inline

{ return fieldCount; }

References fieldCount.

Referenced by DBCStorageBase::Load().

GetFormatRecordSize()

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

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_NA:
            case FT_NA_BYTE:
                break;
            case FT_LOGIC:
                ASSERT(false && "Attempted to load DBC files that do not have field types that match what is in the core. Check DBCfmt.h or your DBC files.");
                break;
            default:
                ASSERT(false && "Unknown field format character in DBCfmt.h");
                break;
        }
    }
 
    if (index_pos)
    {
        *index_pos = i;
    }
 
    return recordsize;
}

References ASSERT, FT_BYTE, FT_FLOAT, FT_IND, FT_INT, FT_LOGIC, FT_NA, FT_NA_BYTE, FT_SORT, and FT_STRING.

Referenced by AutoProduceData(), DBCDatabaseLoader::DBCDatabaseLoader(), and LoadDBC().

GetNumRows()

uint32 DBCFileLoader::GetNumRows ( ) const

inline

{ return recordCount; }

References recordCount.

GetOffset()

uint32 DBCFileLoader::GetOffset ( std::size_t  id ) const

inline

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

References fieldCount, and fieldsOffset.

Referenced by DBCFileLoader::Record::getFloat(), DBCFileLoader::Record::getUInt(), and DBCFileLoader::Record::getUInt8().

getRecord()

DBCFileLoader::Record DBCFileLoader::getRecord

(

std::size_t

id

)

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

References ASSERT, data, and recordSize.

Referenced by AutoProduceData(), and AutoProduceStrings().

GetRowSize()

uint32 DBCFileLoader::GetRowSize ( ) const

inline

{ return recordSize; }

References recordSize.

IsLoaded()

bool DBCFileLoader::IsLoaded ( ) const

inline

{ return data != nullptr; }

References data.

Load()

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

{
    uint32 header;
    if (data)
    {
        delete [] data;
        data = nullptr;
    }
 
    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] == 'b' || fmt[i - 1] == 'X')         // byte fields
        {
            fieldsOffset[i] += sizeof(uint8);
        }
        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;
}

References data, EndianConvert(), fieldCount, fieldsOffset, recordCount, recordSize, stringSize, and stringTable.

Referenced by DBCStorageBase::Load(), and DBCStorageBase::LoadStringsFrom().

operator=()

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

privatedelete

Member Data Documentation

data

unsigned char* DBCFileLoader::data

private

Referenced by getRecord(), IsLoaded(), Load(), and ~DBCFileLoader().

fieldCount

uint32 DBCFileLoader::fieldCount

private

Referenced by AutoProduceData(), AutoProduceStrings(), GetCols(), DBCFileLoader::Record::getFloat(), GetOffset(), DBCFileLoader::Record::getString(), DBCFileLoader::Record::getUInt(), DBCFileLoader::Record::getUInt8(), and Load().

fieldsOffset

uint32* DBCFileLoader::fieldsOffset

private

Referenced by GetOffset(), Load(), and ~DBCFileLoader().

recordCount

uint32 DBCFileLoader::recordCount

private

Referenced by AutoProduceData(), AutoProduceStrings(), GetNumRows(), and Load().

recordSize

uint32 DBCFileLoader::recordSize

private

Referenced by getRecord(), GetRowSize(), and Load().

stringSize

uint32 DBCFileLoader::stringSize

private

Referenced by AutoProduceStrings(), DBCFileLoader::Record::getString(), and Load().

stringTable

unsigned char* DBCFileLoader::stringTable

private

Referenced by AutoProduceStrings(), DBCFileLoader::Record::getString(), and Load().