Updated DALStorage -> Storage in error messages

Finishing 213af0fbde3f198ad1ab2143d32fc6798b7f8f50.

3 files changed, 78 insertions, 78 deletions

diff --git a/src/account-server/storage.cpp b/src/account-server/storage.cpp
index ea2b0eff..308f96fa 100644
--- a/src/account-server/storage.cpp
+++ b/src/account-server/storage.cpp
@@ -152,7 +152,7 @@ void Storage::open()
     }
     catch (const DbConnectionFailure& e)
     {
-        utils::throwError("(DALStorage::open) "
+        utils::throwError("(Storage::open) "
                           "Unable to connect to the database: ", e);
     }
 }
@@ -241,7 +241,7 @@ std::unique_ptr<Account> Storage::getAccountBySQL()
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getAccountBySQL) SQL query failure: ",
+        utils::throwError("(Storage::getAccountBySQL) SQL query failure: ",
                           e);
     }
 
@@ -310,7 +310,7 @@ void Storage::fixCharactersSlot(int accountId)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::fixCharactersSlots) "
+        utils::throwError("(Storage::fixCharactersSlots) "
                           "SQL query failure: ", e);
     }
 }
@@ -486,7 +486,7 @@ CharacterData *Storage::getCharacterBySQL(Account *owner)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("DALStorage::getCharacter #1) SQL query failure: ",
+        utils::throwError("Storage::getCharacter #1) SQL query failure: ",
                           e);
     }
 
@@ -522,7 +522,7 @@ CharacterData *Storage::getCharacterBySQL(Account *owner)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("DALStorage::getCharacter #3) SQL query failure: ",
+        utils::throwError("Storage::getCharacter #3) SQL query failure: ",
                           e);
     }
 
@@ -571,7 +571,7 @@ unsigned Storage::getCharacterId(const std::string &name)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("DALStorage::getCharacterId #1) SQL query failure: ",
+        utils::throwError("Storage::getCharacterId #1) SQL query failure: ",
                           e);
     }
     return 0;
@@ -597,13 +597,13 @@ bool Storage::doesUserNameExist(const std::string &name)
         }
         else
         {
-            utils::throwError("(DALStorage::doesUserNameExist) "
+            utils::throwError("(Storage::doesUserNameExist) "
                               "SQL query preparation failure.");
         }
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::doesUserNameExist) SQL query failure: ",
+        utils::throwError("(Storage::doesUserNameExist) SQL query failure: ",
                           e);
     }
 
@@ -630,13 +630,13 @@ bool Storage::doesEmailAddressExist(const std::string &email)
         }
         else
         {
-            utils::throwError("(DALStorage::doesEmailAddressExist) "
+            utils::throwError("(Storage::doesEmailAddressExist) "
                               "SQL query preparation failure.");
         }
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::doesEmailAddressExist) "
+        utils::throwError("(Storage::doesEmailAddressExist) "
                           "SQL query failure: ", e);
     }
 
@@ -664,13 +664,13 @@ bool Storage::doesCharacterNameExist(const std::string& name)
         }
         else
         {
-            utils::throwError("(DALStorage::doesCharacterNameExist) "
+            utils::throwError("(Storage::doesCharacterNameExist) "
                               "SQL query preparation failure.");
         }
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::doesCharacterNameExist) "
+        utils::throwError("(Storage::doesCharacterNameExist) "
                           "SQL query failure: ", e);
     }
 
@@ -704,7 +704,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #1) "
+        utils::throwError("(Storage::updateCharacter #1) "
                           "SQL query failure: ", e);
     }
 
@@ -718,7 +718,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::updateCharacter #2) "
+        utils::throwError("(Storage::updateCharacter #2) "
                           "SQL query failure: ", e);
     }
 
@@ -735,7 +735,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #4) "
+        utils::throwError("(Storage::updateCharacter #4) "
                           "SQL query failure: ", e);
     }
 
@@ -764,7 +764,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #5) "
+        utils::throwError("(Storage::updateCharacter #5) "
                           "SQL query failure: ", e);;
     }
 
@@ -803,7 +803,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #5) "
+        utils::throwError("(Storage::updateCharacter #5) "
                           "SQL query failure: ", e);;
     }
 
@@ -819,7 +819,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #6) "
+        utils::throwError("(Storage::updateCharacter #6) "
                           "SQL query failure: ", e);
     }
 
@@ -851,7 +851,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #7) "
+        utils::throwError("(Storage::updateCharacter #7) "
                           "SQL query failure: ", e);
     }
 
@@ -869,7 +869,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #8) "
+        utils::throwError("(Storage::updateCharacter #8) "
                           "SQL query failure: ", e);
     }
     try
@@ -884,7 +884,7 @@ bool Storage::updateCharacter(CharacterData *character)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::updateCharacter #9) "
+        utils::throwError("(Storage::updateCharacter #9) "
                           "SQL query failure: ", e);
     }
 
@@ -921,13 +921,13 @@ void Storage::addAccount(Account &account)
         }
         else
         {
-            utils::throwError("(DALStorage::addAccount) "
+            utils::throwError("(Storage::addAccount) "
                               "SQL preparation query failure.");
         }
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::addAccount) SQL query failure: ", e);
+        utils::throwError("(Storage::addAccount) SQL query failure: ", e);
     }
 }
 
@@ -961,7 +961,7 @@ void Storage::flush(const Account &account)
         }
         else
         {
-            utils::throwError("(DALStorage::flush) "
+            utils::throwError("(Storage::flush) "
                               "SQL preparation query failure.");
         }
 
@@ -1065,7 +1065,7 @@ void Storage::flush(const Account &account)
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::flush) SQL query failure: ", e);
+        utils::throwError("(Storage::flush) SQL query failure: ", e);
     }
 }
 
@@ -1087,7 +1087,7 @@ void Storage::delAccount(Account &account)
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::delAccount) SQL query failure: ", e);
+        utils::throwError("(Storage::delAccount) SQL query failure: ", e);
     }
 }
 
@@ -1103,7 +1103,7 @@ void Storage::updateLastLogin(const Account &account)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::updateLastLogin) SQL query failure: ",
+        utils::throwError("(Storage::updateLastLogin) SQL query failure: ",
                           e);
     }
 }
@@ -1123,7 +1123,7 @@ void Storage::updateCharacterPoints(int charId,
     }
     catch (dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::updateCharacterPoints) "
+        utils::throwError("(Storage::updateCharacterPoints) "
                           "SQL query failure: ", e);
     }
 }
@@ -1157,7 +1157,7 @@ void Storage::updateAttribute(int charId, unsigned attrId,
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::updateAttribute) SQL query failure: ",
+        utils::throwError("(Storage::updateAttribute) SQL query failure: ",
                           e);
     }
 }
@@ -1189,7 +1189,7 @@ void Storage::updateKillCount(int charId, int monsterId, int kills)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::updateKillCount) SQL query failure: ",
+        utils::throwError("(Storage::updateKillCount) SQL query failure: ",
                           e);
     }
 }
@@ -1209,7 +1209,7 @@ void Storage::insertStatusEffect(int charId, int statusId, int time)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::insertStatusEffect) "
+        utils::throwError("(Storage::insertStatusEffect) "
                           "SQL query failure: ", e);
     }
 }
@@ -1228,7 +1228,7 @@ void Storage::addGuild(Guild *guild)
         }
         else
         {
-            utils::throwError("(DALStorage::addGuild) "
+            utils::throwError("(Storage::addGuild) "
                               "SQL query preparation failure #1.");
         }
 
@@ -1248,13 +1248,13 @@ void Storage::addGuild(Guild *guild)
         }
         else
         {
-            utils::throwError("(DALStorage::addGuild) "
+            utils::throwError("(Storage::addGuild) "
                               "SQL query preparation failure #2.");
         }
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::addGuild) SQL query failure: ", e);
+        utils::throwError("(Storage::addGuild) SQL query failure: ", e);
     }
 }
 
@@ -1270,7 +1270,7 @@ void Storage::removeGuild(Guild *guild)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::removeGuild) SQL query failure: ", e);
+        utils::throwError("(Storage::removeGuild) SQL query failure: ", e);
     }
 }
 
@@ -1289,7 +1289,7 @@ void Storage::addGuildMember(int guildId, int memberId)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::addGuildMember) SQL query failure: ",
+        utils::throwError("(Storage::addGuildMember) SQL query failure: ",
                           e);
     }
 }
@@ -1307,7 +1307,7 @@ void Storage::removeGuildMember(int guildId, int memberId)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::removeGuildMember) SQL query failure: ",
+        utils::throwError("(Storage::removeGuildMember) SQL query failure: ",
                           e);
     }
 }
@@ -1330,7 +1330,7 @@ void Storage::addFloorItem(int mapId, int itemId, int amount,
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::addFloorItem) SQL query failure: ", e);
+        utils::throwError("(Storage::addFloorItem) SQL query failure: ", e);
     }
 }
 
@@ -1351,7 +1351,7 @@ void Storage::removeFloorItem(int mapId, int itemId, int amount,
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::removeFloorItem) SQL query failure: ",
+        utils::throwError("(Storage::removeFloorItem) SQL query failure: ",
                           e);
     }
 }
@@ -1381,7 +1381,7 @@ std::list<FloorItem> Storage::getFloorItemsFromMap(int mapId)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("DALStorage::getFloorItemsFromMap "
+        utils::throwError("Storage::getFloorItemsFromMap "
             "SQL query failure: ", e);
     }
 
@@ -1401,7 +1401,7 @@ void Storage::setMemberRights(int guildId, int memberId, int rights)
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::setMemberRights) SQL query failure: ",
+        utils::throwError("(Storage::setMemberRights) SQL query failure: ",
                           e);
     }
 }
@@ -1463,7 +1463,7 @@ std::map<int, Guild*> Storage::getGuildList()
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
-        utils::throwError("(DALStorage::getGuildList) SQL query failure: ", e);
+        utils::throwError("(Storage::getGuildList) SQL query failure: ", e);
     }
 
     return guilds;
@@ -1487,13 +1487,13 @@ std::string Storage::getQuestVar(int id, const std::string &name)
         }
         else
         {
-            utils::throwError("(DALStorage:getQuestVar) "
+            utils::throwError("(Storage:getQuestVar) "
                               "SQL query preparation failure.");
         }
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getQuestVar) SQL query failure: ", e);
+        utils::throwError("(Storage::getQuestVar) SQL query failure: ", e);
     }
 
     // Should never happen
@@ -1527,13 +1527,13 @@ std::string Storage::getWorldStateVar(const std::string &name, int mapId)
         }
         else
         {
-            utils::throwError("(DALStorage:getWorldStateVar) "
+            utils::throwError("(Storage:getWorldStateVar) "
                               "SQL query preparation failure.");
         }
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getWorldStateVar) SQL query failure: ",
+        utils::throwError("(Storage::getWorldStateVar) SQL query failure: ",
                           e);
     }
 
@@ -1577,13 +1577,13 @@ std::map<std::string, std::string> Storage::getAllWorldStateVars(int mapId)
         }
         else
         {
-            utils::throwError("(DALStorage:getAllWorldStateVar) "
+            utils::throwError("(Storage:getAllWorldStateVar) "
                               "SQL query preparation failure.");
         }
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getWorldStateVar) SQL query failure: ",
+        utils::throwError("(Storage::getWorldStateVar) SQL query failure: ",
                           e);
     }
 
@@ -1632,7 +1632,7 @@ void Storage::setWorldStateVar(const std::string &name,
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::setWorldStateVar) SQL query failure: ",
+        utils::throwError("(Storage::setWorldStateVar) SQL query failure: ",
                           e);
     }
 }
@@ -1659,7 +1659,7 @@ void Storage::setQuestVar(int id, const std::string &name,
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::setQuestVar) SQL query failure: ", e);
+        utils::throwError("(Storage::setQuestVar) SQL query failure: ", e);
     }
 }
 
@@ -1689,7 +1689,7 @@ void Storage::banCharacter(int id, int duration)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::banAccount) SQL query failure: ", e);
+        utils::throwError("(Storage::banAccount) SQL query failure: ", e);
     }
 }
 
@@ -1744,7 +1744,7 @@ void Storage::delCharacter(int charId) const
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::delCharacter) SQL query failure: ", e);
+        utils::throwError("(Storage::delCharacter) SQL query failure: ", e);
     }
 }
 
@@ -1767,7 +1767,7 @@ void Storage::checkBannedAccounts()
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::checkBannedAccounts) "
+        utils::throwError("(Storage::checkBannedAccounts) "
                           "SQL query failure: ", e);
     }
 }
@@ -1784,7 +1784,7 @@ void Storage::setAccountLevel(int id, int level)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::setAccountLevel) SQL query failure: ",
+        utils::throwError("(Storage::setAccountLevel) SQL query failure: ",
                           e);
     }
 }
@@ -1817,7 +1817,7 @@ void Storage::storeLetter(Letter *letter)
             }
             else
             {
-                utils::throwError("(DALStorage::storeLetter) "
+                utils::throwError("(Storage::storeLetter) "
                                   "SQL query preparation failure #1.");
             }
         }
@@ -1844,7 +1844,7 @@ void Storage::storeLetter(Letter *letter)
                 if (mDb->getModifiedRows() == 0)
                 {
                     // This should never happen...
-                    utils::throwError("(DALStorage::storePost) "
+                    utils::throwError("(Storage::storePost) "
                                       "trying to update nonexistant letter.");
                 }
 
@@ -1852,14 +1852,14 @@ void Storage::storeLetter(Letter *letter)
             }
             else
             {
-                utils::throwError("(DALStorage::storeLetter) "
+                utils::throwError("(Storage::storeLetter) "
                                   "SQL query preparation failure #2.");
             }
         }
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::storeLetter) Exception failure: ", e);
+        utils::throwError("(Storage::storeLetter) Exception failure: ", e);
     }
 }
 
@@ -1903,7 +1903,7 @@ Post *Storage::getStoredPost(int playerId)
     }
     catch (const std::exception &e)
     {
-        utils::throwError("(DALStorage::getStoredPost) Exception failure: ", e);
+        utils::throwError("(Storage::getStoredPost) Exception failure: ", e);
     }
 
     return p;
@@ -1934,7 +1934,7 @@ void Storage::deletePost(Letter *letter)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::deletePost) SQL query failure: ", e);
+        utils::throwError("(Storage::deletePost) SQL query failure: ", e);
     }
 }
 
@@ -2027,21 +2027,21 @@ void Storage::syncDatabase()
                     }
                     else
                     {
-                        utils::throwError("(DALStorage::SyncDatabase) "
+                        utils::throwError("(Storage::SyncDatabase) "
                                           "SQL query preparation failure #2.");
                     }
                 }
             }
             else
             {
-                utils::throwError("(DALStorage::SyncDatabase) "
+                utils::throwError("(Storage::SyncDatabase) "
                                   "SQL query preparation failure #1.");
             }
             itemCount++;
         }
         catch (const dal::DbSqlQueryExecFailure &e)
         {
-            utils::throwError("(DALStorage::SyncDatabase) "
+            utils::throwError("(Storage::SyncDatabase) "
                               "SQL query failure: ", e);
         }
     }
@@ -2082,7 +2082,7 @@ void Storage::setOnlineStatus(int charId, bool online)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::setOnlineStatus) SQL query failure: ",
+        utils::throwError("(Storage::setOnlineStatus) SQL query failure: ",
                           e);
     }
 }
@@ -2104,13 +2104,13 @@ void Storage::addTransaction(const Transaction &trans)
         }
         else
         {
-            utils::throwError("(DALStorage::SyncDatabase) "
+            utils::throwError("(Storage::SyncDatabase) "
                               "SQL query preparation failure.");
         }
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::addTransaction) SQL query failure: ",
+        utils::throwError("(Storage::addTransaction) SQL query failure: ",
                           e);
     }
 }
@@ -2140,7 +2140,7 @@ std::vector<Transaction> Storage::getTransactions(unsigned num)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getTransactions) SQL query failure: ",
+        utils::throwError("(Storage::getTransactions) SQL query failure: ",
                           e);
     }
 
@@ -2170,7 +2170,7 @@ std::vector<Transaction> Storage::getTransactions(time_t date)
     }
     catch (const dal::DbSqlQueryExecFailure &e)
     {
-        utils::throwError("(DALStorage::getTransactions) SQL query failure: ",
+        utils::throwError("(Storage::getTransactions) SQL query failure: ",
                           e);
     }
 
diff --git a/src/account-server/storage.h b/src/account-server/storage.h
index ca83e6f1..5d5d7f1a 100644
--- a/src/account-server/storage.h
+++ b/src/account-server/storage.h
@@ -472,7 +472,7 @@ class Storage
         /**
          * Synchronizes the base data in the connected SQL database with the xml
          * files like items.xml.
-         * This method is called once after initialization of DALStorage.
+         * This method is called once after initialization of Storage.
          * Probably this function should be called if a gm requests an online
          * reload of the xml files to load new items or monsters without server
          * restart.
diff --git a/src/utils/throwerror.h b/src/utils/throwerror.h
index 9963022e..5514ace1 100644
--- a/src/utils/throwerror.h
+++ b/src/utils/throwerror.h
@@ -26,10 +26,10 @@
 namespace utils
 {
     /**
-    * throw an error after logging it.
-    *
-    * @param errmsg error introduction string.
-    */
+     * throw an error after logging it.
+     *
+     * @param errmsg error introduction string.
+     */
     inline void throwError(const std::string &errmsg)
     {
         LOG_ERROR(errmsg);
@@ -37,11 +37,11 @@ namespace utils
     }
 
     /**
-    * throw an error after logging it.
-    *
-    * @param errmsg error introduction string.
-    * @param T is the exception instance.
-    */
+     * throw an error after logging it.
+     *
+     * @param errmsg error introduction string.
+     * @param T is the exception instance.
+     */
     template <class T>
     void throwError(std::string errmsg, const T &e)
     {