mirror of
https://github.com/mangosfour/server.git
synced 2025-12-26 07:37:02 +00:00
Added Support for DB2 Reader. Thanks to all Authors
NOTE: extractor need fix/update.
support for VC80/VC90
cmake need update
Signed-off-by: Salja <salja2012@hotmail.de>
This commit is contained in:
Salja
Antz
parent
a6f3ca6ab0
commit
5424aed420
19 changed files with 994 additions and 13 deletions
451
src/shared/Database/DB2FileLoader.cpp
Normal file
451
src/shared/Database/DB2FileLoader.cpp
Normal file
|
|
@ -0,0 +1,451 @@
|
|||
/*
|
||||
* Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "DB2FileLoader.h"
|
||||
|
||||
DB2FileLoader::DB2FileLoader()
|
||||
{
|
||||
data = NULL;
|
||||
fieldsOffset = NULL;
|
||||
}
|
||||
|
||||
bool DB2FileLoader::Load(const char *filename, const char *fmt)
|
||||
{
|
||||
uint32 header = 48;
|
||||
if(data)
|
||||
{
|
||||
delete [] data;
|
||||
data=NULL;
|
||||
}
|
||||
|
||||
FILE * f = fopen(filename, "rb");
|
||||
if(!f)return false;
|
||||
|
||||
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(&unk2,4,1,f)!=1) // Unknown WDB2
|
||||
{
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
EndianConvert(unk2);
|
||||
|
||||
if(fread(&unk3,4,1,f)!=1) // Unknown WDB2
|
||||
{
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
EndianConvert(unk3);
|
||||
|
||||
if(fread(&locale,4,1,f)!=1) // Locales
|
||||
{
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
EndianConvert(locale);
|
||||
|
||||
if(fread(&unk5,4,1,f)!=1) // Unknown WDB2
|
||||
{
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
EndianConvert(unk5);
|
||||
|
||||
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] += 1;
|
||||
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;
|
||||
}
|
||||
|
||||
DB2FileLoader::~DB2FileLoader()
|
||||
{
|
||||
if(data)
|
||||
delete [] data;
|
||||
if(fieldsOffset)
|
||||
delete [] fieldsOffset;
|
||||
}
|
||||
|
||||
DB2FileLoader::Record DB2FileLoader::getRecord(size_t id)
|
||||
{
|
||||
assert(data);
|
||||
return Record(*this, data + id*recordSize);
|
||||
}
|
||||
|
||||
uint32 DB2FileLoader::GetFormatRecordSize(const char * format,int32* index_pos)
|
||||
{
|
||||
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_LOGIC:
|
||||
assert(false && "2 files not have logic field type");
|
||||
break;
|
||||
case FT_NA:
|
||||
case FT_NA_BYTE:
|
||||
break;
|
||||
default:
|
||||
assert(false && "unknown format character");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (index_pos)
|
||||
*index_pos = i;
|
||||
|
||||
return recordsize;
|
||||
}
|
||||
|
||||
uint32 DB2FileLoader::GetFormatStringsFields(const char * format)
|
||||
{
|
||||
uint32 stringfields = 0;
|
||||
for(uint32 x=0; format[x];++x)
|
||||
if (format[x] == FT_STRING)
|
||||
++stringfields;
|
||||
|
||||
return stringfields;
|
||||
}
|
||||
|
||||
char* DB2FileLoader::AutoProduceData(const char* format, uint32& records, 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 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;
|
||||
}
|
||||
|
||||
++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]))=NULL; // will be replaces non-empty or "" strings in AutoProduceStrings
|
||||
offset += sizeof(char*);
|
||||
break;
|
||||
case FT_LOGIC:
|
||||
assert(false && "DBC files not have logic field type");
|
||||
break;
|
||||
case FT_NA:
|
||||
case FT_NA_BYTE:
|
||||
case FT_SORT:
|
||||
break;
|
||||
default:
|
||||
assert(false && "unknown format character");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return dataTable;
|
||||
}
|
||||
|
||||
static char const* const nullStr = "";
|
||||
|
||||
char* DB2FileLoader::AutoProduceStringsArrayHolders(const char* format, char* dataTable)
|
||||
{
|
||||
if(strlen(format)!=fieldCount)
|
||||
return NULL;
|
||||
|
||||
// we store flat holders pool as single memory block
|
||||
size_t stringFields = GetFormatStringsFields(format);
|
||||
// each string field at load have array of string for each locale
|
||||
size_t stringHolderSize = sizeof(char*) * MAX_LOCALE;
|
||||
size_t stringHoldersRecordPoolSize = stringFields * stringHolderSize;
|
||||
size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * recordCount;
|
||||
|
||||
char* stringHoldersPool= new char[stringHoldersPoolSize];
|
||||
|
||||
// dbc strings expected to have at least empty string
|
||||
for(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 stringFieldNum = 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_STRING:
|
||||
{
|
||||
// init dbc string field slots by pointers to string holders
|
||||
char const*** slot = (char const***)(&dataTable[offset]);
|
||||
*slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * y + stringHolderSize*stringFieldNum]);
|
||||
|
||||
++stringFieldNum;
|
||||
offset+=sizeof(char*);
|
||||
break;
|
||||
}
|
||||
case FT_NA:
|
||||
case FT_NA_BYTE:
|
||||
case FT_SORT:
|
||||
break;
|
||||
default:
|
||||
assert(false && "unknown format character");
|
||||
}
|
||||
}
|
||||
|
||||
//send as char* for store in char* pool list for free at unload
|
||||
return stringHoldersPool;
|
||||
}
|
||||
|
||||
char* DB2FileLoader::AutoProduceStrings(const char* format, char* dataTable, LocaleConstant loc)
|
||||
{
|
||||
if(strlen(format)!=fieldCount)
|
||||
return NULL;
|
||||
|
||||
// each string field at load have array of string for each locale
|
||||
size_t stringHolderSize = sizeof(char*) * MAX_LOCALE;
|
||||
|
||||
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:
|
||||
{
|
||||
char** holder = *((char***)(&dataTable[offset]));
|
||||
char** slot = &holder[loc];
|
||||
|
||||
// fill only not filled entries
|
||||
if (*slot == nullStr)
|
||||
{
|
||||
const char * st = getRecord(y).getString(x);
|
||||
*slot=stringPool+(st-(const char*)stringTable);
|
||||
}
|
||||
|
||||
offset+=sizeof(char*);
|
||||
break;
|
||||
}
|
||||
case FT_LOGIC:
|
||||
assert(false && "DBC files not have logic field type");
|
||||
break;
|
||||
case FT_NA:
|
||||
case FT_NA_BYTE:
|
||||
case FT_SORT:
|
||||
break;
|
||||
default:
|
||||
assert(false && "unknown format character");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return stringPool;
|
||||
}
|
||||
109
src/shared/Database/DB2FileLoader.h
Normal file
109
src/shared/Database/DB2FileLoader.h
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
/*
|
||||
* Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef DB2_FILE_LOADER_H
|
||||
#define DB2_FILE_LOADER_H
|
||||
|
||||
#include "Platform/Define.h"
|
||||
#include "Utilities/ByteConverter.h"
|
||||
#include "Common.h"
|
||||
#include <cassert>
|
||||
|
||||
class DB2FileLoader
|
||||
{
|
||||
public:
|
||||
DB2FileLoader();
|
||||
~DB2FileLoader();
|
||||
|
||||
bool Load(const char *filename, const char *fmt);
|
||||
|
||||
class Record
|
||||
{
|
||||
public:
|
||||
float getFloat(size_t field) const
|
||||
{
|
||||
assert(field < file.fieldCount);
|
||||
float val = *reinterpret_cast<float*>(offset+file.GetOffset(field));
|
||||
EndianConvert(val);
|
||||
return val;
|
||||
}
|
||||
uint32 getUInt(size_t field) const
|
||||
{
|
||||
assert(field < file.fieldCount);
|
||||
uint32 val = *reinterpret_cast<uint32*>(offset+file.GetOffset(field));
|
||||
EndianConvert(val);
|
||||
return val;
|
||||
}
|
||||
uint8 getUInt8(size_t field) const
|
||||
{
|
||||
assert(field < file.fieldCount);
|
||||
return *reinterpret_cast<uint8*>(offset+file.GetOffset(field));
|
||||
}
|
||||
|
||||
const char *getString(size_t field) const
|
||||
{
|
||||
assert(field < file.fieldCount);
|
||||
size_t stringOffset = getUInt(field);
|
||||
assert(stringOffset < file.stringSize);
|
||||
return reinterpret_cast<char*>(file.stringTable + stringOffset);
|
||||
}
|
||||
|
||||
private:
|
||||
Record(DB2FileLoader &file_, unsigned char *offset_): offset(offset_), file(file_) {}
|
||||
unsigned char *offset;
|
||||
DB2FileLoader &file;
|
||||
|
||||
friend class DB2FileLoader;
|
||||
|
||||
};
|
||||
|
||||
// Get record by id
|
||||
Record getRecord(size_t id);
|
||||
/// Get begin iterator over records
|
||||
|
||||
uint32 GetNumRows() const { return recordCount;}
|
||||
uint32 GetCols() const { return fieldCount; }
|
||||
uint32 GetOffset(size_t id) const { return (fieldsOffset != NULL && id < fieldCount) ? fieldsOffset[id] : 0; }
|
||||
bool IsLoaded() const { return (data != NULL); }
|
||||
char* AutoProduceData(const char* fmt, uint32& count, char**& indexTable);
|
||||
char* AutoProduceStringsArrayHolders(const char* fmt, char* dataTable);
|
||||
char* AutoProduceStrings(const char* fmt, char* dataTable, LocaleConstant loc);
|
||||
static uint32 GetFormatRecordSize(const char * format, int32 * index_pos = NULL);
|
||||
static uint32 GetFormatStringsFields(const char * format);
|
||||
private:
|
||||
|
||||
uint32 recordSize;
|
||||
uint32 recordCount;
|
||||
uint32 fieldCount;
|
||||
uint32 stringSize;
|
||||
uint32 *fieldsOffset;
|
||||
unsigned char *data;
|
||||
unsigned char *stringTable;
|
||||
|
||||
// WDB2 / WCH2 fields
|
||||
uint32 tableHash; // WDB2
|
||||
uint32 build; // WDB2
|
||||
|
||||
int unk1; // WDB2 (Unix time in WCH2)
|
||||
int unk2; // WDB2
|
||||
int unk3; // WDB2 (index table)
|
||||
int locale; // WDB2
|
||||
int unk5; // WDB2
|
||||
};
|
||||
|
||||
#endif
|
||||
105
src/shared/Database/DB2Store.h
Normal file
105
src/shared/Database/DB2Store.h
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef DB2STORE_H
|
||||
#define DB2STORE_H
|
||||
|
||||
#include "DB2FileLoader.h"
|
||||
|
||||
template<class T>
|
||||
class DB2Storage
|
||||
{
|
||||
typedef std::list<char*> StringPoolList;
|
||||
public:
|
||||
explicit DB2Storage(const char *f) : nCount(0), fieldCount(0), fmt(f), indexTable(NULL), m_dataTable(NULL) { }
|
||||
~DB2Storage() { Clear(); }
|
||||
|
||||
T const* LookupEntry(uint32 id) const { return (id>=nCount)?NULL:indexTable[id]; }
|
||||
uint32 GetNumRows() const { return nCount; }
|
||||
char const* GetFormat() const { return fmt; }
|
||||
uint32 GetFieldCount() const { return fieldCount; }
|
||||
|
||||
bool Load(char const* fn, LocaleConstant loc)
|
||||
{
|
||||
DB2FileLoader db2;
|
||||
// Check if load was sucessful, only then continue
|
||||
if(!db2.Load(fn, fmt))
|
||||
return false;
|
||||
|
||||
fieldCount = db2.GetCols();
|
||||
|
||||
// load raw non-string data
|
||||
m_dataTable = (T*)db2.AutoProduceData(fmt,nCount,(char**&)indexTable);
|
||||
|
||||
// create string holders for loaded string fields
|
||||
m_stringPoolList.push_back(db2.AutoProduceStringsArrayHolders(fmt,(char*)m_dataTable));
|
||||
|
||||
// load strings from dbc data
|
||||
m_stringPoolList.push_back(db2.AutoProduceStrings(fmt,(char*)m_dataTable,loc));
|
||||
|
||||
// error in dbc file at loading if NULL
|
||||
return indexTable!=NULL;
|
||||
}
|
||||
|
||||
bool LoadStringsFrom(char const* fn, LocaleConstant loc)
|
||||
{
|
||||
// DBC must be already loaded using Load
|
||||
if(!indexTable)
|
||||
return false;
|
||||
|
||||
DB2FileLoader db2;
|
||||
// Check if load was successful, only then continue
|
||||
if(!db2.Load(fn, fmt))
|
||||
return false;
|
||||
|
||||
// load strings from another locale dbc data
|
||||
m_stringPoolList.push_back(db2.AutoProduceStrings(fmt,(char*)m_dataTable,loc));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void Clear()
|
||||
{
|
||||
if (!indexTable)
|
||||
return;
|
||||
|
||||
delete[] ((char*)indexTable);
|
||||
indexTable = NULL;
|
||||
delete[] ((char*)m_dataTable);
|
||||
m_dataTable = NULL;
|
||||
|
||||
while(!m_stringPoolList.empty())
|
||||
{
|
||||
delete[] m_stringPoolList.front();
|
||||
m_stringPoolList.pop_front();
|
||||
}
|
||||
nCount = 0;
|
||||
}
|
||||
|
||||
void EraseEntry(uint32 id) { indexTable[id] = NULL; }
|
||||
|
||||
private:
|
||||
uint32 nCount;
|
||||
uint32 fieldCount;
|
||||
char const* fmt;
|
||||
T** indexTable;
|
||||
T* m_dataTable;
|
||||
StringPoolList m_stringPoolList;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -23,7 +23,7 @@
|
|||
#include "Common.h"
|
||||
#include <cassert>
|
||||
|
||||
enum
|
||||
/*enum
|
||||
{
|
||||
FT_NA = 'x', // ignore/ default, 4 byte size, in Source String means field is ignored, in Dest String means field is filled with default value
|
||||
FT_NA_BYTE = 'X', // ignore/ default, 1 byte size, see above
|
||||
|
|
@ -36,7 +36,7 @@ enum
|
|||
FT_SORT = 'd', // sorted by this field, field is not included
|
||||
FT_IND = 'n', // the same,but parsed to data
|
||||
FT_LOGIC = 'l' // Logical (boolean)
|
||||
};
|
||||
};*/
|
||||
|
||||
class DBCFileLoader
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue