Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-16 07:30:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Removing SQLStorage class leftovers

Browse Source
This commit is contained in:
leak
2011-04-28 23:03:02 +02:00
parent c51c817a45
commit 6d1924cee8
16 changed files with 0 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/server/game/AI/EventAI/CreatureEventAIMgr.cpp
View File

@@ -18,7 +18,6 @@
#include "Common.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "CreatureEventAI.h"
#include "CreatureEventAIMgr.h"
#include "ObjectMgr.h"

1
src/server/game/AI/SmartScripts/SmartAI.cpp
View File

@@ -16,7 +16,6 @@
*/
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "ObjectMgr.h"
#include "ObjectDefines.h"
#include "GridDefines.h"

1
src/server/game/AI/SmartScripts/SmartScript.cpp
View File

@@ -16,7 +16,6 @@
*/
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "ObjectMgr.h"
#include "ObjectDefines.h"
#include "GridDefines.h"

1
src/server/game/AI/SmartScripts/SmartScriptMgr.cpp
View File

@@ -16,7 +16,6 @@
*/
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "ObjectMgr.h"
#include "ObjectDefines.h"
#include "GridDefines.h"

1
src/server/game/AuctionHouse/AuctionHouseMgr.cpp
View File

@@ -23,7 +23,6 @@
#include "WorldPacket.h"
#include "WorldSession.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "DBCStores.h"
#include "ScriptMgr.h"
#include "AccountMgr.h"

38
src/server/game/Globals/ObjectMgr.cpp
View File

@@ -18,8 +18,6 @@
#include "Common.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "SQLStorageImpl.h"
#include "Log.h"
#include "MapManager.h"
#include "ObjectMgr.h"
@@ -534,15 +532,6 @@ void ObjectMgr::LoadPointOfInterestLocales()
sLog->outString();
}
struct SQLCreatureLoader : public SQLStorageLoaderBase<SQLCreatureLoader>
{
template<class D>
void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
{
dst = D(sObjectMgr->GetScriptId(src));
}
};
void ObjectMgr::LoadCreatureTemplates()
{
uint32 oldMSTime = getMSTime();
@@ -2275,15 +2264,6 @@ void ObjectMgr::LoadItemLocales()
sLog->outString();
}
struct SQLItemLoader : public SQLStorageLoaderBase<SQLItemLoader>
{
template<class D>
void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
{
dst = D(sObjectMgr->GetScriptId(src));
}
};
void ObjectMgr::LoadItemTemplates()
{
uint32 oldMSTime = getMSTime();
@@ -5856,15 +5836,6 @@ void ObjectMgr::LoadPageTextLocales()
sLog->outString();
}
struct SQLInstanceLoader : public SQLStorageLoaderBase<SQLInstanceLoader>
{
template<class D>
void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
{
dst = D(sObjectMgr->GetScriptId(src));
}
};
void ObjectMgr::LoadInstanceTemplate()
{
uint32 oldMSTime = getMSTime();
@@ -7167,15 +7138,6 @@ void ObjectMgr::LoadGameObjectLocales()
sLog->outString();
}
struct SQLGameObjectLoader : public SQLStorageLoaderBase<SQLGameObjectLoader>
{
template<class D>
void convert_from_str(uint32 /*field_pos*/, char *src, D &dst)
{
dst = D(sObjectMgr->GetScriptId(src));
}
};
inline void CheckGOLockId(GameObjectTemplate* goInfo,uint32 dataN,uint32 N)
{
if (sLockStore.LookupEntry(dataN))

1
src/server/game/Globals/ObjectMgr.h
View File

@@ -36,7 +36,6 @@
#include "ObjectAccessor.h"
#include "ObjectDefines.h"
#include <ace/Singleton.h>
#include "SQLStorage.h"
#include "Vehicle.h"
#include <string>
#include <map>

1
src/server/game/Instances/InstanceSaveMgr.cpp
View File

@@ -17,7 +17,6 @@
*/
#include "Common.h"
#include "SQLStorage.h"
#include "Player.h"
#include "GridNotifiers.h"
#include "Log.h"

1
src/server/game/PrecompiledHeaders/gamePCH.h
View File

@@ -8,7 +8,6 @@
#include "Log.h"
#include "ObjectAccessor.h"
#include "ObjectDefines.h"
#include "SQLStorage.h"
#include "Opcodes.h"
#include "SharedDefines.h"
#include "ObjectMgr.h"

1
src/server/game/Spells/SpellMgr.h
View File

@@ -27,7 +27,6 @@
#include "SpellAuraDefines.h"
#include "DBCStructure.h"
#include "DBCStores.h"
#include "SQLStorage.h"
#include "UnorderedMap.h"

1
src/server/game/Texts/CreatureTextMgr.cpp
View File

@@ -17,7 +17,6 @@
#include "Common.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "CreatureTextMgr.h"
#include "ObjectMgr.h"

2
src/server/game/Tickets/TicketMgr.cpp
View File

@@ -19,8 +19,6 @@
#include "Common.h"
#include "TicketMgr.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "SQLStorageImpl.h"
#include "Log.h"
#include "WorldPacket.h"
#include "WorldSession.h"

1
src/server/game/Tools/PlayerDump.cpp
View File

@@ -19,7 +19,6 @@
#include "Common.h"
#include "PlayerDump.h"
#include "DatabaseEnv.h"
#include "SQLStorage.h"
#include "UpdateFields.h"
#include "ObjectMgr.h"
#include "AccountMgr.h"

72
src/server/shared/Database/SQLStorage.cpp
View File

@@ -1,72 +0,0 @@
/*
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 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, see <http://www.gnu.org/licenses/>.
*/
#include "SQLStorage.h"
#include "SQLStorageImpl.h"
void SQLStorage::Free ()
{
uint32 offset = 0;
for (uint32 x = 0; x < iNumFields; ++x)
{
switch(dst_format[x])
{
case FT_BYTE:
offset += sizeof(char);
break;
case FT_FLOAT:
offset += sizeof(float);
break;
case FT_LOGIC:
offset += sizeof(bool);
break;
case FT_INT:
offset += sizeof(uint32);
break;
case FT_STRING:
{
for (uint32 y = 0; y < MaxEntry; ++y)
if (pIndex[y])
delete [] *(char**)((char*)(pIndex[y])+offset);
offset += sizeof(char*);
break;
}
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage has a field type that does not match what is in the core. Check SQLStorage.cpp or your database.");
break;
default:
assert(false && "Unknown field format character in SQLStorage.cpp");
break;
}
}
delete [] pIndex;
delete [] data;
}
void SQLStorage::Load()
{
SQLStorageLoader loader;
loader.Load(*this);
}

116
src/server/shared/Database/SQLStorage.h
View File

@@ -1,116 +0,0 @@
/*
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef SQLSTORAGE_H
#define SQLSTORAGE_H
#include "Common.h"
#include "DatabaseEnv.h"
class SQLStorage
{
template<class T>
friend struct SQLStorageLoaderBase;
public:
SQLStorage(const char* fmt, const char * _entry_field, const char * sqlname)
{
src_format = fmt;
dst_format = fmt;
init(_entry_field, sqlname);
}
SQLStorage(const char* src_fmt, const char* dst_fmt, const char * _entry_field, const char * sqlname)
{
src_format = src_fmt;
dst_format = dst_fmt;
init(_entry_field, sqlname);
}
~SQLStorage()
{
Free();
}
template<class T>
T const* LookupEntry(uint32 id) const
{
if( id == 0 )
return NULL;
if(id >= MaxEntry)
return NULL;
return reinterpret_cast<T const*>(pIndex[id]);
}
uint32 RecordCount;
uint32 MaxEntry;
uint32 iNumFields;
char const* GetTableName() const { return table; }
void Load();
void Free();
private:
void init(const char * _entry_field, const char * sqlname)
{
entry_field = _entry_field;
table=sqlname;
data=NULL;
pIndex=NULL;
iNumFields = strlen(src_format);
MaxEntry = 0;
}
char** pIndex;
char *data;
const char *src_format;
const char *dst_format;
const char *table;
const char *entry_field;
//bool HasString;
};
template <class T>
struct SQLStorageLoaderBase
{
public:
void Load(SQLStorage &storage);
template<class S, class D>
void convert(uint32 field_pos, S src, D &dst);
template<class S>
void convert_to_str(uint32 field_pos, S src, char * & dst);
template<class D>
void convert_from_str(uint32 field_pos, char * src, D& dst);
void convert_str_to_str(uint32 field_pos, char *src, char *&dst);
private:
template<class V>
void storeValue(V value, SQLStorage &store, char *p, int x, uint32 &offset);
void storeValue(char * value, SQLStorage &store, char *p, int x, uint32 &offset);
};
struct SQLStorageLoader : public SQLStorageLoaderBase<SQLStorageLoader>
{
};
#endif

256
src/server/shared/Database/SQLStorageImpl.h
View File

@@ -1,256 +0,0 @@
/*
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 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, see <http://www.gnu.org/licenses/>.
*/
#include "Log.h"
#include "DBCFileLoader.h"
template<class T>
template<class S, class D>
void SQLStorageLoaderBase<T>::convert(uint32 /*field_pos*/, S src, D& dst)
{
dst = D(src);
}
template<class T>
void SQLStorageLoaderBase<T>::convert_str_to_str(uint32 /*field_pos*/, char* src, char*& dst)
{
if (!src)
{
dst = new char[1];
*dst = 0;
}
else
{
uint32 l = strlen(src) + 1;
dst = new char[l];
memcpy(dst, src, l);
}
}
template<class T>
template<class S>
void SQLStorageLoaderBase<T>::convert_to_str(uint32 /*field_pos*/, S /*src*/, char*& dst)
{
dst = new char[1];
*dst = 0;
}
template<class T>
template<class D>
void SQLStorageLoaderBase<T>::convert_from_str(uint32 /*field_pos*/, char* /*src*/, D& dst)
{
dst = 0;
}
template<class T>
template<class V>
void SQLStorageLoaderBase<T>::storeValue(V value, SQLStorage& store, char* p, int x, uint32 &offset)
{
T* subclass = (static_cast<T*>(this));
switch (store.dst_format[x])
{
case FT_LOGIC:
subclass->convert(x, value, *((bool*)(&p[offset])) );
offset += sizeof(bool);
break;
case FT_BYTE:
subclass->convert(x, value, *((char*)(&p[offset])) );
offset += sizeof(char);
break;
case FT_INT:
subclass->convert(x, value, *((uint32*)(&p[offset])) );
offset += sizeof(uint32);
break;
case FT_FLOAT:
subclass->convert(x, value, *((float*)(&p[offset])) );
offset += sizeof(float);
break;
case FT_STRING:
subclass->convert_to_str(x, value, *((char**)(&p[offset])) );
offset += sizeof(char*);
break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_SORT:
assert(false && "SQL storage has a field type that does not match what is in the core. Check SQLStorage.cpp or your database.");
break;
default:
assert(false && "Unknown field format character in SQLStorage.cpp");
}
}
template<class T>
void SQLStorageLoaderBase<T>::storeValue(char* value, SQLStorage& store, char* p, int x, uint32& offset)
{
T* subclass = (static_cast<T*>(this));
switch (store.dst_format[x])
{
case FT_LOGIC:
subclass->convert_from_str(x, value, *((bool*)(&p[offset])) );
offset += sizeof(bool);
break;
case FT_BYTE:
subclass->convert_from_str(x, value, *((char*)(&p[offset])) );
offset += sizeof(char);
break;
case FT_INT:
subclass->convert_from_str(x, value, *((uint32*)(&p[offset])) );
offset += sizeof(uint32);
break;
case FT_FLOAT:
subclass->convert_from_str(x, value, *((float*)(&p[offset])) );
offset += sizeof(float);
break;
case FT_STRING:
subclass->convert_str_to_str(x, value, *((char**)(&p[offset])) );
offset += sizeof(char*);
break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_SORT:
assert(false && "SQL storage has a field type that does not match what is in the core. Check SQLStorage.cpp or your database.");
break;
default:
assert(false && "Unknown field format character in SQLStorage.cpp");
}
}
template<class T>
void SQLStorageLoaderBase<T>::Load(SQLStorage& store)
{
uint32 maxi;
Field* fields;
QueryResult result = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s", store.entry_field, store.table);
if (!result)
{
sLog->outError("Error loading %s table (does not exist?)\n", store.table);
exit(1); // Stop server at loading non exited table or not accessable table
}
maxi = result->Fetch()[0].GetUInt32() + 1;
result = WorldDatabase.PQuery("SELECT COUNT(*) FROM %s", store.table);
if (result)
{
fields = result->Fetch();
store.RecordCount = fields[0].GetUInt32();
}
else
store.RecordCount = 0;
result = WorldDatabase.PQuery("SELECT * FROM %s", store.table);
if (!result)
{
sLog->outError("%s table is empty!\n", store.table);
store.RecordCount = 0;
return;
}
uint32 recordsize = 0;
uint32 offset = 0;
if (store.iNumFields != result->GetFieldCount())
{
store.RecordCount = 0;
sLog->outError("Error loading table %s, probably table format was updated (there should be %u fields in sql).\n", store.table, store.iNumFields);
exit(1); // Stop server at loading broken or non-compatible table.
}
for (uint32 x = 0; x < store.iNumFields; ++x)
{
switch (store.dst_format[x])
{
case FT_LOGIC:
recordsize += sizeof(bool);
break;
case FT_BYTE:
recordsize += sizeof(char);
break;
case FT_INT:
recordsize += sizeof(uint32);
break;
case FT_FLOAT:
recordsize += sizeof(float);
break;
case FT_STRING:
recordsize += sizeof(char*);
break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage does not have sort field types!");
break;
default:
assert(false && "Unknown field format character in SQLStorage.cpp");
break;
}
}
char** newIndex = new char*[maxi];
memset(newIndex, 0, maxi * sizeof(char*));
char * _data = new char[store.RecordCount * recordsize];
uint32 count = 0;
do
{
fields = result->Fetch();
char* p = (char*)&_data[recordsize * count];
newIndex[fields[0].GetUInt32()] = p;
offset = 0;
for (uint32 x = 0; x < store.iNumFields; ++x)
switch (store.src_format[x])
{
case FT_LOGIC:
storeValue((bool)(fields[x].GetUInt32() > 0), store, p, x, offset);
break;
case FT_BYTE:
storeValue((char)fields[x].GetUInt8(), store, p, x, offset);
break;
case FT_INT:
storeValue((uint32)fields[x].GetUInt32(), store, p, x, offset);
break;
case FT_FLOAT:
storeValue((float)fields[x].GetFloat(), store, p, x, offset);
break;
case FT_STRING:
storeValue((char*)fields[x].GetCString(), store, p, x, offset);
break;
case FT_NA:
case FT_NA_BYTE:
break;
case FT_IND:
case FT_SORT:
assert(false && "SQL storage has a field type that is not allowed. Check your SQLStorage.cpp!");
break;
default:
assert(false && "Unknown field format character in SQLStorage.cpp");
}
++count;
} while (result->NextRow());
store.pIndex = newIndex;
store.MaxEntry = maxi;
store.data = _data;
}