** Cleanup in ObjectAccessor/HashMapHolder:

* Correctly lock the HashMapHolder on access.
* Use ObjectAccessor wrappers (GetPlayers, GetCreatures, GetGameObjects) instead of raw HashMapHolder<Type>::GetContainer.
* General code style cleanup.

--HG--
branch : trunk

6 files changed, 154 insertions, 179 deletions

diff --git a/src/game/LFGHandler.cpp b/src/game/LFGHandler.cpp
index 63fc3ad2439..6fa0199d6ff 100644
--- a/src/game/LFGHandler.cpp
+++ b/src/game/LFGHandler.cpp
@@ -32,7 +32,7 @@ static void AttemptJoin(Player* _player)
     if(!_player->m_lookingForGroup.canAutoJoin() || _player->GetGroup())
         return;
 
-    //TODO: Guard Player Map
+    ObjectAccessor::Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType const& players = ObjectAccessor::Instance().GetPlayers();
     for (HashMapHolder<Player>::MapType::const_iterator iter = players.begin(); iter != players.end(); ++iter)
     {
@@ -92,7 +92,7 @@ static void AttemptAddMore(Player* _player)
     if(!_player->m_lookingForGroup.more.canAutoJoin())
         return;
 
-    //TODO: Guard Player map
+    ObjectAccessor::Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType const& players = ObjectAccessor::Instance().GetPlayers();
     for (HashMapHolder<Player>::MapType::const_iterator iter = players.begin(); iter != players.end(); ++iter)
     {
diff --git a/src/game/Level0.cpp b/src/game/Level0.cpp
index b1853c93d77..3117bfaacb0 100644
--- a/src/game/Level0.cpp
+++ b/src/game/Level0.cpp
@@ -165,9 +165,9 @@ bool ChatHandler::HandleGMListIngameCommand(const char* /*args*/)
 {
     bool first = true;
 
-    HashMapHolder<Player>::MapType &m = HashMapHolder<Player>::GetContainer();
-    HashMapHolder<Player>::MapType::const_iterator itr = m.begin();
-    for (; itr != m.end(); ++itr)
+    ObjectAccessor::Guard guard(*HashMapHolder<Player>::GetLock());
+    HashMapHolder<Player>::MapType &m = ObjectAccessor::Instance().GetPlayers();
+    for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
     {
         AccountTypes itr_sec = itr->second->GetSession()->GetSecurity();
         if ((itr->second->isGameMaster() || (itr_sec > SEC_PLAYER && itr_sec <= sWorld.getConfig(CONFIG_GM_LEVEL_IN_GM_LIST))) &&
diff --git a/src/game/Level3.cpp b/src/game/Level3.cpp
index c4dab15fa57..82350b1f2b9 100644
--- a/src/game/Level3.cpp
+++ b/src/game/Level3.cpp
@@ -5361,6 +5361,8 @@ bool ChatHandler::HandleResetAllCommand(const char * args)
     }
 
     CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE (at_login & '%u') = '0'",atLogin,atLogin);
+    
+    ObjectAccessor::Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType const& plist = ObjectAccessor::Instance().GetPlayers();
     for (HashMapHolder<Player>::MapType::const_iterator itr = plist.begin(); itr != plist.end(); ++itr)
         itr->second->SetAtLoginFlag(atLogin);
diff --git a/src/game/MiscHandler.cpp b/src/game/MiscHandler.cpp
index cf9515c3db9..095c4389ae7 100644
--- a/src/game/MiscHandler.cpp
+++ b/src/game/MiscHandler.cpp
@@ -220,7 +220,7 @@ void WorldSession::HandleWhoOpcode( WorldPacket & recv_data )
     data << clientcount;                                    // clientcount place holder
     data << clientcount;                                    // clientcount place holder
 
-    //TODO: Guard Player map
+    ObjectAccessor::Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType& m = ObjectAccessor::Instance().GetPlayers();
     for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
     {
diff --git a/src/game/ObjectAccessor.cpp b/src/game/ObjectAccessor.cpp
index 365115fcb8f..867b9df4e3e 100644
--- a/src/game/ObjectAccessor.cpp
+++ b/src/game/ObjectAccessor.cpp
@@ -45,7 +45,10 @@
 INSTANTIATE_SINGLETON_2(ObjectAccessor, CLASS_LOCK);
 INSTANTIATE_CLASS_MUTEX(ObjectAccessor, ACE_Thread_Mutex);
 
-ObjectAccessor::ObjectAccessor() {}
+ObjectAccessor::ObjectAccessor()
+{
+}
+
 ObjectAccessor::~ObjectAccessor()
 {
     for (Player2CorpsesMapType::const_iterator itr = i_player2corpse.begin(); itr != i_player2corpse.end(); ++itr)
@@ -55,71 +58,57 @@ ObjectAccessor::~ObjectAccessor()
     }
 }
 
-Creature*
-ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const &u, uint64 guid)
+Creature* ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const& u, uint64 guid)
 {
-    if(IS_PLAYER_GUID(guid))
+    if (IS_PLAYER_GUID(guid))
         return NULL;
 
-    if(IS_PET_GUID(guid))
+    if (IS_PET_GUID(guid))
         return GetPet(guid);
 
     return u.IsInWorld() ? u.GetMap()->GetCreature(guid) : NULL;
 }
 
-/*
-Unit*
-ObjectAccessor::GetUnit(WorldObject const &u, uint64 guid)
+Corpse* ObjectAccessor::GetCorpse(WorldObject const& u, uint64 guid)
 {
-    if(!guid)
-        return NULL;
+    Corpse* ret = GetObjectInWorld(guid, (Corpse*)NULL);
 
-    if(IS_PLAYER_GUID(guid))
-        return FindPlayer(guid);
-
-    return GetCreatureOrPetOrVehicle(u, guid);
-}
-*/
-
-Corpse*
-ObjectAccessor::GetCorpse(WorldObject const &u, uint64 guid)
-{
-    Corpse * ret = GetObjectInWorld(guid, (Corpse*)NULL);
-    if(!ret)
+    if (!ret)
         return NULL;
-    if(ret->GetMapId() != u.GetMapId())
+
+    if (ret->GetMapId() != u.GetMapId())
         return NULL;
-    if(ret->GetInstanceId() != u.GetInstanceId())
+
+    if (ret->GetInstanceId() != u.GetInstanceId())
         return NULL;
+
     return ret;
 }
 
-WorldObject* ObjectAccessor::GetWorldObject(WorldObject const &p, uint64 guid)
+WorldObject* ObjectAccessor::GetWorldObject(WorldObject const& p, uint64 guid)
 {
-    switch(GUID_HIPART(guid))
+    switch (GUID_HIPART(guid))
     {
-        case HIGHGUID_PLAYER:       return FindPlayer(guid);
-        case HIGHGUID_GAMEOBJECT:   return p.GetMap()->GetGameObject(guid);
+        case HIGHGUID_PLAYER:        return FindPlayer(guid);
+        case HIGHGUID_GAMEOBJECT:    return p.GetMap()->GetGameObject(guid);
         case HIGHGUID_VEHICLE:
-        case HIGHGUID_UNIT:         return p.GetMap()->GetCreature(guid);
-        case HIGHGUID_PET:          return GetPet(guid);
-        case HIGHGUID_DYNAMICOBJECT:return p.GetMap()->GetDynamicObject(guid);
-        case HIGHGUID_TRANSPORT:    return NULL;
-        case HIGHGUID_CORPSE:       return GetCorpse(p,guid);
-        case HIGHGUID_MO_TRANSPORT: return NULL;
-        default: break;
+        case HIGHGUID_UNIT:          return p.GetMap()->GetCreature(guid);
+        case HIGHGUID_PET:           return GetPet(guid);
+        case HIGHGUID_DYNAMICOBJECT: return p.GetMap()->GetDynamicObject(guid);
+        case HIGHGUID_TRANSPORT:     return NULL;
+        case HIGHGUID_CORPSE:        return GetCorpse(p,guid);
+        case HIGHGUID_MO_TRANSPORT:  return NULL;
+        default:                     return NULL;
     }
-
-    return NULL;
 }
 
-Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, uint32 typemask)
+Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const& p, uint64 guid, uint32 typemask)
 {
-    switch(GUID_HIPART(guid))
+    switch (GUID_HIPART(guid))
     {
         case HIGHGUID_ITEM:
-            if(typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)
-                return ((Player const &)p).GetItemByGuid( guid );
+            if (typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)
+                return ((Player const&)p).GetItemByGuid(guid);
             break;
         case HIGHGUID_PLAYER:
             if(typemask & TYPEMASK_PLAYER)
@@ -151,135 +140,133 @@ Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, u
     return NULL;
 }
 
-Player*
-ObjectAccessor::FindPlayer(uint64 guid)
+Player* ObjectAccessor::FindPlayer(uint64 guid)
 {
-    Player * plr = GetObjectInWorld(guid, (Player*)NULL);
-    if(!plr || !plr->IsInWorld())
+    Player* plr = GetObjectInWorld(guid, (Player*)NULL);
+    if (!plr || !plr->IsInWorld())
         return NULL;
 
     return plr;
 }
 
-Player*
-ObjectAccessor::FindPlayerByName(const char *name)
+Player* ObjectAccessor::FindPlayerByName(const char* name)
 {
-    //TODO: Player Guard
     Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
-    HashMapHolder<Player>::MapType::iterator iter = m.begin();
-    for (; iter != m.end(); ++iter)
-        if(iter->second->IsInWorld() && ( ::strcmp(name, iter->second->GetName()) == 0 ))
+    for (HashMapHolder<Player>::MapType::iterator iter = m.begin(); iter != m.end(); ++iter)
+        if (iter->second->IsInWorld() && strcmp(name, iter->second->GetName()) == 0)
             return iter->second;
+
     return NULL;
 }
 
-void
-ObjectAccessor::SaveAllPlayers()
+void ObjectAccessor::SaveAllPlayers()
 {
     Guard guard(*HashMapHolder<Player>::GetLock());
     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
-    HashMapHolder<Player>::MapType::iterator itr = m.begin();
-    for (; itr != m.end(); ++itr)
+    for (HashMapHolder<Player>::MapType::iterator itr = m.begin(); itr != m.end(); ++itr)
         itr->second->SaveToDB();
 }
 
-Pet*
-ObjectAccessor::GetPet(uint64 guid)
+Pet* ObjectAccessor::GetPet(uint64 guid)
 {
     return GetObjectInWorld(guid, (Pet*)NULL);
 }
 
-Corpse*
-ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
+Corpse* ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
 {
     Guard guard(i_corpseGuard);
 
     Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
-    if( iter == i_player2corpse.end() ) return NULL;
+    if (iter == i_player2corpse.end())
+        return NULL;
 
     assert(iter->second->GetType() != CORPSE_BONES);
 
     return iter->second;
 }
 
-void
-ObjectAccessor::RemoveCorpse(Corpse *corpse)
+void ObjectAccessor::RemoveCorpse(Corpse* corpse)
 {
     assert(corpse && corpse->GetType() != CORPSE_BONES);
 
-    if(corpse->FindMap())
+    if (corpse->FindMap())
         corpse->FindMap()->Remove(corpse, false);
     else
         corpse->RemoveFromWorld();
 
-    Guard guard(i_corpseGuard);
-    Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
-    if( iter == i_player2corpse.end() ) // i do not know when it happens but it happens
-        return;
+    // Critical section
+    {
+        Guard guard(i_corpseGuard);
 
-    // build mapid*cellid -> guid_set map
-    CellPair cell_pair = Trinity::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
-    uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
+        Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
+        if (iter == i_player2corpse.end()) // TODO: Fix this
+            return;
 
-    objmgr.DeleteCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID());
+        // build mapid*cellid -> guid_set map
+        CellPair cell_pair = Trinity::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
+        uint32 cell_id = (cell_pair.y_coord * TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 
-    i_player2corpse.erase(iter);
+        objmgr.DeleteCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID());
+
+        i_player2corpse.erase(iter);
+    }
 }
 
-void
-ObjectAccessor::AddCorpse(Corpse *corpse)
+void ObjectAccessor::AddCorpse(Corpse* corpse)
 {
     assert(corpse && corpse->GetType() != CORPSE_BONES);
 
-    Guard guard(i_corpseGuard);
-    assert(i_player2corpse.find(corpse->GetOwnerGUID()) == i_player2corpse.end());
-    i_player2corpse[corpse->GetOwnerGUID()] = corpse;
+    // Critical section
+    {
+        Guard guard(i_corpseGuard);
+
+        assert(i_player2corpse.find(corpse->GetOwnerGUID()) == i_player2corpse.end());
+        i_player2corpse[corpse->GetOwnerGUID()] = corpse;
 
-    // build mapid*cellid -> guid_set map
-    CellPair cell_pair = Trinity::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
-    uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
+        // build mapid*cellid -> guid_set map
+        CellPair cell_pair = Trinity::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
+        uint32 cell_id = (cell_pair.y_coord * TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 
-    objmgr.AddCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID(), corpse->GetInstanceId());
+        objmgr.AddCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID(), corpse->GetInstanceId());
+    }
 }
 
-void
-ObjectAccessor::AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map)
+void ObjectAccessor::AddCorpsesToGrid(GridPair const& gridpair, GridType& grid, Map* map)
 {
     Guard guard(i_corpseGuard);
+
     for (Player2CorpsesMapType::iterator iter = i_player2corpse.begin(); iter != i_player2corpse.end(); ++iter)
-        if(iter->second->GetGrid() == gridpair)
     {
-        // verify, if the corpse in our instance (add only corpses which are)
-        if (map->Instanceable())
+        if (iter->second->GetGrid() == gridpair)
         {
-            if (iter->second->GetInstanceId() == map->GetInstanceId())
+            // verify, if the corpse in our instance (add only corpses which are)
+            if (map->Instanceable())
             {
-                grid.AddWorldObject(iter->second);
+                if (iter->second->GetInstanceId() == map->GetInstanceId())
+                    grid.AddWorldObject(iter->second);
             }
-        }
-        else
-        {
-            grid.AddWorldObject(iter->second);
+            else
+                grid.AddWorldObject(iter->second);
         }
     }
 }
 
-Corpse*
-ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
+Corpse* ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 {
-    Corpse *corpse = GetCorpseForPlayerGUID(player_guid);
+    Corpse* corpse = GetCorpseForPlayerGUID(player_guid);
     if(!corpse)
     {
         //in fact this function is called from several places
         //even when player doesn't have a corpse, not an error
+        // TODO: really, now...
         //sLog.outError("Try remove corpse that not in map for GUID %ul", player_guid);
         return NULL;
     }
 
     DEBUG_LOG("Deleting Corpse and spawning bones.");
 
-    Map *map = corpse->FindMap();
+    Map* map = corpse->FindMap();
 
     // remove corpse from player_guid -> corpse map
     RemoveCorpse(corpse);
@@ -298,7 +285,7 @@ ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
     delete corpse;
     return NULL;
 
-    Corpse *bones = NULL;
+    Corpse* bones = NULL;
     // create the bones only if the map and the grid is loaded at the corpse's location
     // ignore bones creating option in case insignia
     if (map && (insignia ||
@@ -314,7 +301,7 @@ ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 
         bones->SetGrid(corpse->GetGrid());
         // bones->m_time = m_time;                              // don't overwrite time
-        // bones->m_inWorld = m_inWorld;                        // don't overwrite world state
+        // bones->m_inWorld = m_inWorld;                        // don't overwrite in-world state
         // bones->m_type = m_type;                              // don't overwrite type
         bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
         bones->SetPhaseMask(corpse->GetPhaseMask(), false);
@@ -324,7 +311,7 @@ ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 
         for (int i = 0; i < EQUIPMENT_SLOT_END; ++i)
         {
-            if(corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
+            if (corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
                 bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
         }
 
@@ -338,13 +325,15 @@ ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
     return bones;
 }
 
-void
-ObjectAccessor::Update(uint32 diff)
+void ObjectAccessor::Update(uint32 diff)
 {
     UpdateDataMapType update_players;
+
+    // Critical section
     {
         Guard guard(i_updateGuard);
-        while(!i_objects.empty())
+
+        while (!i_objects.empty())
         {
             Object* obj = *i_objects.begin();
             assert(obj && obj->IsInWorld());
@@ -362,28 +351,7 @@ ObjectAccessor::Update(uint32 diff)
     }
 }
 
-
-/*void ObjectAccessor::UpdateVisibilityForPlayer( Player* player )
-{
-    WorldObject const* viewPoint = player->GetViewPoint();
-    Map* m = player->GetMap();
-
-    CellPair p = Trinity::ComputeCellPair(player->GetPositionX(), player->GetPositionY());
-    Cell cell(p);
-
-    m->UpdatePlayerVisibility(player, cell, p);
-    if (player!=viewPoint)
-    {
-        CellPair pView(Trinity::ComputeCellPair(viewPoint->GetPositionX(), viewPoint->GetPositionY()));
-        Cell cellView(pView);
-
-        m->UpdateObjectsVisibilityFor(player, cellView, pView);
-    }
-    else
-        m->UpdateObjectsVisibilityFor(player, cell, p);
-}*/
-
-/// Define the static member of HashMapHolder
+/// Define the static members of HashMapHolder
 
 template <class T> UNORDERED_MAP< uint64, T* > HashMapHolder<T>::m_objectMap;
 template <class T> ACE_Thread_Mutex HashMapHolder<T>::i_lock;
diff --git a/src/game/ObjectAccessor.h b/src/game/ObjectAccessor.h
index 9667686bb40..9134dd730f7 100644
--- a/src/game/ObjectAccessor.h
+++ b/src/game/ObjectAccessor.h
@@ -48,9 +48,9 @@ class HashMapHolder
 {
     public:
 
-        typedef UNORDERED_MAP< uint64, T* >   MapType;
+        typedef UNORDERED_MAP<uint64, T*> MapType;
         typedef ACE_Thread_Mutex LockType;
-        typedef Trinity::GeneralLock<LockType > Guard;
+        typedef Trinity::GeneralLock<LockType> Guard;
 
         static void Insert(T* o)
         {
@@ -74,6 +74,7 @@ class HashMapHolder
         static MapType& GetContainer() { return m_objectMap; }
 
         static LockType* GetLock() { return &i_lock; }
+
     private:
 
         //Non instanceable only static
@@ -85,15 +86,15 @@ class HashMapHolder
 
 class ObjectAccessor : public Trinity::Singleton<ObjectAccessor, Trinity::ClassLevelLockable<ObjectAccessor, ACE_Thread_Mutex> >
 {
-
     friend class Trinity::OperatorNew<ObjectAccessor>;
     ObjectAccessor();
     ~ObjectAccessor();
-    ObjectAccessor(const ObjectAccessor &);
-    ObjectAccessor& operator=(const ObjectAccessor &);
+    ObjectAccessor(const ObjectAccessor&);
+    ObjectAccessor& operator=(const ObjectAccessor&);
 
     public:
-        typedef UNORDERED_MAP<uint64, Corpse* >      Player2CorpsesMapType;
+
+        typedef UNORDERED_MAP<uint64, Corpse*> Player2CorpsesMapType;
         typedef UNORDERED_MAP<Player*, UpdateData>::value_type UpdateDataValueType;
 
         template<class T> static T* GetObjectInWorld(uint64 guid, T* /*fake*/)
@@ -103,19 +104,19 @@ class ObjectAccessor : public Trinity::Singleton<ObjectAccessor, Trinity::ClassL
 
         static Unit* GetObjectInWorld(uint64 guid, Unit* /*fake*/)
         {
-            if(!guid)
+            if (!guid)
                 return NULL;
 
             if (IS_PLAYER_GUID(guid))
             {
-                Unit * u = (Unit*)HashMapHolder<Player>::Find(guid);
-                if(!u || !u->IsInWorld())
+                Unit* u = (Unit*)HashMapHolder<Player>::Find(guid);
+                if (!u || !u->IsInWorld())
                     return NULL;
 
                 return u;
             }
 
-            if(IS_PET_GUID(guid))
+            if (IS_PET_GUID(guid))
                 return (Unit*)HashMapHolder<Pet>::Find(guid);
 
             return (Unit*)HashMapHolder<Creature>::Find(guid);
@@ -123,34 +124,36 @@ class ObjectAccessor : public Trinity::Singleton<ObjectAccessor, Trinity::ClassL
 
         static Unit* GetUnitInOrOutOfWorld(uint64 guid, Unit* /*fake*/)
         {
-            if(!guid)
+            if (!guid)
                 return NULL;
 
             if (IS_PLAYER_GUID(guid))
             {
-                Unit * u = (Unit*)HashMapHolder<Player>::Find(guid);
+                Unit* u = (Unit*)HashMapHolder<Player>::Find(guid);
                 if(!u)
                     return NULL;
 
                 return u;
             }
+
             // Other object types than player are unloaded while out of world
-            return GetObjectInWorld(guid, ((Unit*)NULL));
+            return GetObjectInWorld(guid, (Unit*)NULL);
         }
 
         template<class T> static T* GetObjectInWorld(uint32 mapid, float x, float y, uint64 guid, T* /*fake*/)
         {
             T* obj = HashMapHolder<T>::Find(guid);
-            if(!obj || obj->GetMapId() != mapid) return NULL;
+            if (!obj || obj->GetMapId() != mapid)
+                return NULL;
 
-            CellPair p = Trinity::ComputeCellPair(x,y);
-            if(p.x_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP || p.y_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP )
+            CellPair p = Trinity::ComputeCellPair(x, y);
+            if (p.x_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP || p.y_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP )
             {
                 sLog.outError("ObjectAccessor::GetObjectInWorld: invalid coordinates supplied X:%f Y:%f grid cell [%u:%u]", x, y, p.x_coord, p.y_coord);
                 return NULL;
             }
 
-            CellPair q = Trinity::ComputeCellPair(obj->GetPositionX(),obj->GetPositionY());
+            CellPair q = Trinity::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
             if(q.x_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP || q.y_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP )
             {
                 sLog.outError("ObjectAccessor::GetObjecInWorld: object (GUID: %u TypeId: %u) has invalid coordinates X:%f Y:%f grid cell [%u:%u]", obj->GetGUIDLow(), obj->GetTypeId(), obj->GetPositionX(), obj->GetPositionY(), q.x_coord, q.y_coord);
@@ -160,65 +163,68 @@ class ObjectAccessor : public Trinity::Singleton<ObjectAccessor, Trinity::ClassL
             int32 dx = int32(p.x_coord) - int32(q.x_coord);
             int32 dy = int32(p.y_coord) - int32(q.y_coord);
 
-            if (dx > -2 && dx < 2 && dy > -2 && dy < 2) return obj;
-            else return NULL;
+            if (dx > -2 && dx < 2 && dy > -2 && dy < 2)
+                return obj;
+            else
+                return NULL;
         }
 
-        static WorldObject* GetWorldObject(WorldObject const &, uint64);
-        static Object*   GetObjectByTypeMask(WorldObject const &, uint64, uint32 typemask);
-        static Creature* GetCreatureOrPetOrVehicle(WorldObject const &, uint64);
-        static Unit* GetUnit(WorldObject const &, uint64 guid) { return GetObjectInWorld(guid, (Unit*)NULL); }
-        static Unit* GetUnitInOrOutOfWorld(WorldObject const &, uint64 guid) { return GetUnitInOrOutOfWorld(guid, (Unit*)NULL); }
-        static Pet* GetPet(Unit const &, uint64 guid) { return GetPet(guid); }
-        static Player* GetPlayer(Unit const &, uint64 guid) { return FindPlayer(guid); }
-        static Corpse* GetCorpse(WorldObject const &u, uint64 guid);
+        static WorldObject* GetWorldObject(WorldObject const&, uint64);
+        static Object* GetObjectByTypeMask(WorldObject const&, uint64, uint32 typemask);
+        static Creature* GetCreatureOrPetOrVehicle(WorldObject const&, uint64);
+        static Unit* GetUnit(WorldObject const&, uint64 guid) { return GetObjectInWorld(guid, (Unit*)NULL); }
+        static Unit* GetUnitInOrOutOfWorld(WorldObject const&, uint64 guid) { return GetUnitInOrOutOfWorld(guid, (Unit*)NULL); }
+        static Pet* GetPet(Unit const&, uint64 guid) { return GetPet(guid); }
+        static Player* GetPlayer(Unit const&, uint64 guid) { return FindPlayer(guid); }
+        static Corpse* GetCorpse(WorldObject const& u, uint64 guid);
         static Pet* GetPet(uint64 guid);
         static Player* FindPlayer(uint64);
 
-        Player* FindPlayerByName(const char *name) ;
+        Player* FindPlayerByName(const char* name) ;
 
+        // when using this, you must use the hashmapholder's lock
         HashMapHolder<Player>::MapType& GetPlayers()
         {
             return HashMapHolder<Player>::GetContainer();
         }
 
+        // when using this, you must use the hashmapholder's lock
         HashMapHolder<Creature>::MapType& GetCreatures()
         {
             return HashMapHolder<Creature>::GetContainer();
         }
 
+        // when using this, you must use the hashmapholder's lock
         HashMapHolder<GameObject>::MapType& GetGameObjects()
         {
             return HashMapHolder<GameObject>::GetContainer();
         }
 
-        template<class T> void AddObject(T *object)
+        template<class T> void AddObject(T* object)
         {
             HashMapHolder<T>::Insert(object);
         }
 
-        template<class T> void RemoveObject(T *object)
+        template<class T> void RemoveObject(T* object)
         {
             HashMapHolder<T>::Remove(object);
         }
 
-        void RemoveObject(Player *pl)
+        void RemoveObject(Player* pl)
         {
             HashMapHolder<Player>::Remove(pl);
-
-            Guard guard(i_updateGuard);
-            i_objects.erase((Object *)pl);
+            RemoveUpdateObject((Object*)pl);
         }
 
         void SaveAllPlayers();
 
-        void AddUpdateObject(Object *obj)
+        void AddUpdateObject(Object* obj)
         {
             Guard guard(i_updateGuard);
             i_objects.insert(obj);
         }
 
-        void RemoveUpdateObject(Object *obj)
+        void RemoveUpdateObject(Object* obj)
         {
             Guard guard(i_updateGuard);
             i_objects.erase( obj );
@@ -227,26 +233,25 @@ class ObjectAccessor : public Trinity::Singleton<ObjectAccessor, Trinity::ClassL
         void Update(uint32 diff);
 
         Corpse* GetCorpseForPlayerGUID(uint64 guid);
-        void RemoveCorpse(Corpse *corpse);
-        void AddCorpse(Corpse *corpse);
-        void AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map);
+        void RemoveCorpse(Corpse* corpse);
+        void AddCorpse(Corpse* corpse);
+        void AddCorpsesToGrid(GridPair const& gridpair, GridType& grid, Map* map);
         Corpse* ConvertCorpseForPlayer(uint64 player_guid, bool insignia = false);
 
-        //static void UpdateVisibilityForPlayer(Player* player);
+        typedef ACE_Thread_Mutex LockType;
+        typedef Trinity::GeneralLock<LockType> Guard;
+
     private:
 
-        Player2CorpsesMapType   i_player2corpse;
+        Player2CorpsesMapType i_player2corpse;
 
-        typedef ACE_Thread_Mutex LockType;
-        typedef Trinity::GeneralLock<LockType > Guard;
+        static void _buildChangeObjectForPlayer(WorldObject*, UpdateDataMapType&);
+        static void _buildPacket(Player*, Object*, UpdateDataMapType&);
+        void _update();
+
+        std::set<Object*> i_objects;
 
-        static void _buildChangeObjectForPlayer(WorldObject *, UpdateDataMapType &);
-        static void _buildPacket(Player *, Object *, UpdateDataMapType &);
-        void _update(void);
-        std::set<Object *> i_objects;
-        LockType i_playerGuard;
         LockType i_updateGuard;
         LockType i_corpseGuard;
-        LockType i_petGuard;
 };
 #endif