Core/Storage: Add some sanity checks and better define some SQL and DBC

storage format field types.
* Also LOTS of whitespace cleanup
* Some Trinity code style applied
* Some if / else if -> switch / case
* Original ideal for patch by Vinolentus

2 files changed, 100 insertions, 57 deletions

diff --git a/src/server/shared/Database/SQLStorage.cpp b/src/server/shared/Database/SQLStorage.cpp
index 7371cbded85..c568fe9a74e 100755
--- a/src/server/shared/Database/SQLStorage.cpp
+++ b/src/server/shared/Database/SQLStorage.cpp
@@ -45,22 +45,44 @@ SQLStorage sInstanceTemplate(InstanceTemplatesrcfmt, InstanceTemplatedstfmt, "ma
 
 void SQLStorage::Free ()
 {
-    uint32 offset=0;
-    for (uint32 x=0; x<iNumFields; x++)
-        if (dst_format[x]==FT_STRING)
+    uint32 offset = 0;
+    for (uint32 x = 0; x < iNumFields; ++x)
+    {
+        switch(dst_format[x])
         {
-            for (uint32 y=0; y<MaxEntry; y++)
-                if(pIndex[y])
-                    delete [] *(char**)((char*)(pIndex[y])+offset);
+            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*);
+                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;
         }
-        else if (dst_format[x]==FT_LOGIC)
-            offset += sizeof(bool);
-        else if (dst_format[x]==FT_BYTE)
-            offset += sizeof(char);
-        else
-            offset += 4;
+    }
 
     delete [] pIndex;
     delete [] data;
diff --git a/src/server/shared/Database/SQLStorageImpl.h b/src/server/shared/Database/SQLStorageImpl.h
index 153a6b6499c..a629e09e5e4 100755
--- a/src/server/shared/Database/SQLStorageImpl.h
+++ b/src/server/shared/Database/SQLStorageImpl.h
@@ -29,7 +29,7 @@ void SQLStorageLoaderBase<T>::convert(uint32 /*field_pos*/, S src, D &dst)
 template<class T>
 void SQLStorageLoaderBase<T>::convert_str_to_str(uint32 /*field_pos*/, char *src, char *&dst)
 {
-    if(!src)
+    if (!src)
     {
         dst = new char[1];
         *dst = 0;
@@ -66,24 +66,32 @@ void SQLStorageLoaderBase<T>::storeValue(V value, SQLStorage &store, char *p, in
     {
         case FT_LOGIC:
             subclass->convert(x, value, *((bool*)(&p[offset])) );
-            offset+=sizeof(bool);
+            offset += sizeof(bool);
             break;
         case FT_BYTE:
             subclass->convert(x, value, *((char*)(&p[offset])) );
-            offset+=sizeof(char);
+            offset += sizeof(char);
             break;
         case FT_INT:
             subclass->convert(x, value, *((uint32*)(&p[offset])) );
-            offset+=sizeof(uint32);
+            offset += sizeof(uint32);
             break;
         case FT_FLOAT:
             subclass->convert(x, value, *((float*)(&p[offset])) );
-            offset+=sizeof(float);
+            offset += sizeof(float);
             break;
         case FT_STRING:
             subclass->convert_to_str(x, value, *((char**)(&p[offset])) );
-            offset+=sizeof(char*);
+            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");
     }
 }
 
@@ -95,24 +103,32 @@ void SQLStorageLoaderBase<T>::storeValue(char * value, SQLStorage &store, char *
     {
         case FT_LOGIC:
             subclass->convert_from_str(x, value, *((bool*)(&p[offset])) );
-            offset+=sizeof(bool);
+            offset += sizeof(bool);
             break;
         case FT_BYTE:
             subclass->convert_from_str(x, value, *((char*)(&p[offset])) );
-            offset+=sizeof(char);
+            offset += sizeof(char);
             break;
         case FT_INT:
             subclass->convert_from_str(x, value, *((uint32*)(&p[offset])) );
-            offset+=sizeof(uint32);
+            offset += sizeof(uint32);
             break;
         case FT_FLOAT:
             subclass->convert_from_str(x, value, *((float*)(&p[offset])) );
-            offset+=sizeof(float);
+            offset += sizeof(float);
             break;
         case FT_STRING:
             subclass->convert_str_to_str(x, value, *((char**)(&p[offset])) );
-            offset+=sizeof(char*);
+            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");
     }
 }
 
@@ -121,17 +137,17 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store)
 {
     uint32 maxi;
     Field *fields;
-    QueryResult result  = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s", store.entry_field, store.table);
+    QueryResult result = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s", store.entry_field, store.table);
     if(!result)
     {
         sLog->outError("Error loading %s table (not exist?)\n", store.table);
         exit(1);                                            // Stop server at loading non exited table or not accessable table
     }
 
-    maxi = (*result)[0].GetUInt32()+1;
+    maxi = (*result)[0].GetUInt32() + 1;
 
     result = WorldDatabase.PQuery("SELECT COUNT(*) FROM %s", store.table);
-    if(result)
+    if (result)
     {
         fields = result->Fetch();
         store.RecordCount = fields[0].GetUInt32();
@@ -141,7 +157,7 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store)
 
     result = WorldDatabase.PQuery("SELECT * FROM %s", store.table);
 
-    if(!result)
+    if (!result)
     {
         sLog->outError("%s table is empty!\n", store.table);
         store.RecordCount = 0;
@@ -151,54 +167,59 @@ void SQLStorageLoaderBase<T>::Load(SQLStorage &store)
     uint32 recordsize = 0;
     uint32 offset = 0;
 
-    if(store.iNumFields != result->GetFieldCount())
+    if (store.iNumFields != result->GetFieldCount())
     {
         store.RecordCount = 0;
         sLog->outError("Error in %s table, probably sql file format was updated (there should be %d fields in sql).\n", store.table, store.iNumFields);
         exit(1);                                            // Stop server at loading broken or non-compatible table.
     }
 
-    //get struct size
-    uint32 sc=0;
-    uint32 bo=0;
-    uint32 bb=0;
-    for (uint32 x=0; x< store.iNumFields; x++)
-        if(store.dst_format[x]==FT_STRING)
-            ++sc;
-        else if (store.dst_format[x]==FT_LOGIC)
-            ++bo;
-        else if (store.dst_format[x]==FT_BYTE)
-            ++bb;
-    recordsize=(store.iNumFields-sc-bo-bb)*4+sc*sizeof(char*)+bo*sizeof(bool)+bb*sizeof(char);
-
-    char** newIndex=new char*[maxi];
-    memset(newIndex,0,maxi*sizeof(char*));
-
-    char * _data= new char[store.RecordCount *recordsize];
-    uint32 count=0;
+    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;
+        char *p = (char*)&_data[recordsize*count];
+        newIndex[fields[0].GetUInt32()] = p;
 
-        offset=0;
-        for (uint32 x = 0; x < store.iNumFields; x++)
+        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;
+                    storeValue((bool)(fields[x].GetUInt32() > 0), store, p, x, offset);
+                    break;
                 case FT_BYTE:
-                    storeValue((char)fields[x].GetUInt8(), store, p, x, offset); break;
+                    storeValue((char)fields[x].GetUInt8(), store, p, x, offset);
+                    break;
                 case FT_INT:
-                    storeValue((uint32)fields[x].GetUInt32(), store, p, x, offset); break;
+                    storeValue((uint32)fields[x].GetUInt32(), store, p, x, offset);
+                    break;
                 case FT_FLOAT:
-                    storeValue((float)fields[x].GetFloat(), store, p, x, offset); break;
+                    storeValue((float)fields[x].GetFloat(), store, p, x, offset);
+                    break;
                 case FT_STRING:
-                    storeValue((char*)fields[x].GetCString(), store, p, x, offset); break;
+                    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 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");
+
             }
         ++count;
-    }while( result->NextRow() );
+    }
+    while( result->NextRow() );
+
+    delete result;
 
     store.pIndex = newIndex;
     store.MaxEntry = maxi;