Core/DataStores: Implemented a generic way of sending db2 hotfixes

3 files changed, 98 insertions, 19 deletions

diff --git a/src/server/shared/DataStores/DB2FileLoader.cpp b/src/server/shared/DataStores/DB2FileLoader.cpp
index 0de3b94b5d4..83e6e83104f 100644
--- a/src/server/shared/DataStores/DB2FileLoader.cpp
+++ b/src/server/shared/DataStores/DB2FileLoader.cpp
@@ -30,17 +30,17 @@ DB2FileLoader::DB2FileLoader()
 
 bool DB2FileLoader::Load(const char *filename, const char *fmt)
 {
-    uint32 header = 48;
     if (data)
     {
         delete [] data;
-        data=NULL;
+        data = NULL;
     }
 
     FILE* f = fopen(filename, "rb");
     if (!f)
         return false;
 
+    uint32 header;
     if (fread(&header, 4, 1, f) != 1)                        // Signature
     {
         fclose(f);
@@ -114,12 +114,12 @@ bool DB2FileLoader::Load(const char *filename, const char *fmt)
 
     if (build > 12880)
     {
-        if (fread(&unk2, 4, 1, f) != 1)                // Unknown WDB2
+        if (fread(&minIndex, 4, 1, f) != 1)                           // MinIndex WDB2
         {
             fclose(f);
             return false;
         }
-        EndianConvert(unk2);
+        EndianConvert(minIndex);
 
         if (fread(&maxIndex, 4, 1, f) != 1)                           // MaxIndex WDB2
         {
@@ -145,7 +145,7 @@ bool DB2FileLoader::Load(const char *filename, const char *fmt)
 
     if (maxIndex != 0)
     {
-        int32 diff = maxIndex - unk2 + 1;
+        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
     }
 
diff --git a/src/server/shared/DataStores/DB2FileLoader.h b/src/server/shared/DataStores/DB2FileLoader.h
index c30e33c29f6..5d3c8449442 100644
--- a/src/server/shared/DataStores/DB2FileLoader.h
+++ b/src/server/shared/DataStores/DB2FileLoader.h
@@ -25,8 +25,8 @@
 class DB2FileLoader
 {
     public:
-        DB2FileLoader();
-        ~DB2FileLoader();
+    DB2FileLoader();
+    ~DB2FileLoader();
 
     bool Load(const char *filename, const char *fmt);
 
@@ -76,6 +76,7 @@ class DB2FileLoader
     uint32 GetNumRows() const { return recordCount;}
     uint32 GetCols() const { return fieldCount; }
     uint32 GetOffset(size_t id) const { return (fieldsOffset != NULL && id < fieldCount) ? fieldsOffset[id] : 0; }
+    uint32 GetHash() const { return tableHash; }
     bool IsLoaded() const { return (data != NULL); }
     char* AutoProduceData(const char* fmt, uint32& count, char**& indexTable);
     char* AutoProduceStringsArrayHolders(const char* fmt, char* dataTable);
@@ -97,7 +98,7 @@ private:
     uint32 build;        // WDB2
 
     int unk1;            // WDB2 (Unix time in WCH2)
-    int unk2;            // WDB2
+    int minIndex;        // WDB2
     int maxIndex;        // WDB2 (index table)
     int locale;          // WDB2
     int unk5;            // WDB2
diff --git a/src/server/shared/DataStores/DB2Store.h b/src/server/shared/DataStores/DB2Store.h
index c8f51bc96cb..e4f91beb592 100644
--- a/src/server/shared/DataStores/DB2Store.h
+++ b/src/server/shared/DataStores/DB2Store.h
@@ -19,30 +19,105 @@
 #define DB2STORE_H
 
 #include "DB2FileLoader.h"
-#include "DB2fmt.h"
-#include "Log.h"
-#include "Field.h"
-#include "DatabaseWorkerPool.h"
-#include "Implementation/WorldDatabase.h"
-#include "DatabaseEnv.h"
-
+#include "ByteBuffer.h"
 #include <vector>
 
+/// Interface class for common access
+class DB2StorageBase
+{
+public:
+    virtual ~DB2StorageBase() { }
+
+    uint32 GetHash() const { return tableHash; }
+
+    virtual bool HasRecord(uint32 id) const = 0;
+
+    virtual void WriteRecord(uint32 id, ByteBuffer& buffer) const = 0;
+
+protected:
+    uint32 tableHash;
+};
+
+template<class T>
+class DB2Storage;
+
+template<class T>
+bool DB2StorageHasEntry(DB2Storage<T> const& store, uint32 id)
+{
+    return store.LookupEntry(id) != NULL;
+}
+
 template<class T>
-class DB2Storage
+void WriteDB2RecordToPacket(DB2Storage<T> const& store, uint32 id, ByteBuffer& buffer)
+{
+    uint8 const* entry = (uint8 const*)store.LookupEntry(id);
+    ASSERT(entry);
+
+    std::string format = store.GetFormat();
+    for (uint32 i = 0; i < format.length(); ++i)
+    {
+        switch (format[i])
+        {
+            case FT_IND:
+            case FT_INT:
+                buffer << *(uint32*)entry;
+                entry += 4;
+                break;
+            case FT_FLOAT:
+                buffer << *(float*)entry;
+                entry += 4;
+                break;
+            case FT_BYTE:
+                buffer << *(uint8*)entry;
+                entry += 1;
+                break;
+            case FT_STRING:
+            {
+                size_t len = strlen(*(char**)entry);
+                buffer << uint16(len);
+                if (len)
+                    buffer << *(char**)entry;
+                entry += sizeof(char*);
+                break;
+            }
+            case FT_NA:
+            case FT_SORT:
+                buffer << uint32(0);
+                break;
+            case FT_NA_BYTE:
+                buffer << uint8(0);
+                break;
+        }
+    }
+}
+
+template<class T>
+class DB2Storage : public DB2StorageBase
 {
     typedef std::list<char*> StringPoolList;
     typedef std::vector<T*> DataTableEx;
+    typedef bool(*EntryChecker)(DB2Storage<T> const&, uint32);
+    typedef void(*PacketWriter)(DB2Storage<T> const&, uint32, ByteBuffer&);
 public:
-    explicit DB2Storage(char const* f) : nCount(0), fieldCount(0), fmt(f), indexTable(NULL), m_dataTable(NULL) { }
+    DB2Storage(char const* f, EntryChecker checkEntry = NULL, PacketWriter writePacket = NULL) :
+        nCount(0), fieldCount(0), fmt(f), indexTable(NULL), m_dataTable(NULL)
+    {
+        CheckEntry = checkEntry ? checkEntry : &DB2StorageHasEntry<T>;
+        WritePacket = writePacket ? writePacket : &WriteDB2RecordToPacket<T>;
+    }
+
     ~DB2Storage() { Clear(); }
 
+    bool HasRecord(uint32 id) const { return CheckEntry(*this, id); }
     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; }
+    void WriteRecord(uint32 id, ByteBuffer& buffer) const
+    {
+        WritePacket(*this, id, buffer);
+    }
 
-    /// Copies the provided entry and stores it.
     T* CreateEntry(uint32 id, bool evenIfExists = false)
     {
         if (evenIfExists && LookupEntry(id))
@@ -75,6 +150,7 @@ public:
             return false;
 
         fieldCount = db2.GetCols();
+        tableHash = db2.GetHash();
 
         // load raw non-string data
         m_dataTable = (T*)db2.AutoProduceData(fmt, nCount, (char**&)indexTable);
@@ -130,10 +206,12 @@ public:
         nCount = 0;
     }
 
+    EntryChecker CheckEntry;
+    PacketWriter WritePacket;
+
 private:
     uint32 nCount;
     uint32 fieldCount;
-    uint32 recordSize;
     char const* fmt;
     T** indexTable;
     T* m_dataTable;