diff --git a/src/framework/Dynamic/FactoryHolder.h b/src/framework/Dynamic/FactoryHolder.h
index 617007e71..3a89d6ef6 100644
--- a/src/framework/Dynamic/FactoryHolder.h
+++ b/src/framework/Dynamic/FactoryHolder.h
@@ -41,7 +41,7 @@ class MANGOS_DLL_DECL FactoryHolder
         void DeregisterSelf(void) { FactoryHolderRepository::Instance().RemoveItem(this, false); }
 
         /// Abstract Factory create method
-        virtual T* Create(void *data = NULL) const = 0;
+        virtual T* Create(void* data = NULL) const = 0;
     private:
         Key i_key;
 };
@@ -55,6 +55,6 @@ class Permissible
 {
     public:
         virtual ~Permissible() {}
-        virtual int Permit(const T *) const = 0;
+        virtual int Permit(const T*) const = 0;
 };
 #endif
diff --git a/src/framework/Dynamic/ObjectRegistry.h b/src/framework/Dynamic/ObjectRegistry.h
index 12aae8652..a17bed07d 100644
--- a/src/framework/Dynamic/ObjectRegistry.h
+++ b/src/framework/Dynamic/ObjectRegistry.h
@@ -33,22 +33,22 @@ template<class T, class Key = std::string>
 class MANGOS_DLL_DECL ObjectRegistry
 {
     public:
-        typedef std::map<Key, T *> RegistryMapType;
+        typedef std::map<Key, T*> RegistryMapType;
 
         /// Returns a registry item
         const T* GetRegistryItem(Key key) const
         {
             typename RegistryMapType::const_iterator iter = i_registeredObjects.find(key);
-            return( iter == i_registeredObjects.end() ? NULL : iter->second );
+            return(iter == i_registeredObjects.end() ? NULL : iter->second);
         }
 
         /// Inserts a registry item
-        bool InsertItem(T *obj, Key key, bool replace = false)
+        bool InsertItem(T* obj, Key key, bool replace = false)
         {
             typename RegistryMapType::iterator iter = i_registeredObjects.find(key);
-            if( iter != i_registeredObjects.end() )
+            if (iter != i_registeredObjects.end())
             {
-                if( !replace )
+                if (!replace)
                     return false;
                 delete iter->second;
                 i_registeredObjects.erase(iter);
@@ -62,9 +62,9 @@ class MANGOS_DLL_DECL ObjectRegistry
         void RemoveItem(Key key, bool delete_object = true)
         {
             typename RegistryMapType::iterator iter = i_registeredObjects.find(key);
-            if( iter != i_registeredObjects.end() )
+            if (iter != i_registeredObjects.end())
             {
-                if( delete_object )
+                if (delete_object)
                     delete iter->second;
                 i_registeredObjects.erase(iter);
             }
@@ -77,17 +77,17 @@ class MANGOS_DLL_DECL ObjectRegistry
         }
 
         /// Inefficiently return a vector of registered items
-        unsigned int GetRegisteredItems(std::vector<Key> &l) const
+        unsigned int GetRegisteredItems(std::vector<Key>& l) const
         {
             unsigned int sz = l.size();
             l.resize(sz + i_registeredObjects.size());
-            for(typename RegistryMapType::const_iterator iter = i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
+            for (typename RegistryMapType::const_iterator iter = i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
                 l[sz++] = iter->first;
             return i_registeredObjects.size();
         }
 
         /// Return the map of registered items
-        RegistryMapType const &GetRegisteredItems() const
+        RegistryMapType const& GetRegisteredItems() const
         {
             return i_registeredObjects;
         }
@@ -100,7 +100,7 @@ class MANGOS_DLL_DECL ObjectRegistry
         ObjectRegistry() {}
         ~ObjectRegistry()
         {
-            for(typename RegistryMapType::iterator iter=i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
+            for (typename RegistryMapType::iterator iter=i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
                 delete iter->second;
             i_registeredObjects.clear();
         }
diff --git a/src/framework/GameSystem/Grid.h b/src/framework/GameSystem/Grid.h
index 3f9c8a7e4..e92531b2c 100644
--- a/src/framework/GameSystem/Grid.h
+++ b/src/framework/GameSystem/Grid.h
@@ -41,13 +41,13 @@ template<class A, class T, class O> class GridLoader;
 template
 <
 class ACTIVE_OBJECT,
-class WORLD_OBJECT_TYPES,
-class GRID_OBJECT_TYPES
->
+      class WORLD_OBJECT_TYPES,
+      class GRID_OBJECT_TYPES
+      >
 class MANGOS_DLL_DECL Grid
 {
-    // allows the GridLoader to access its internals
-    template<class A, class T, class O> friend class GridLoader;
+        // allows the GridLoader to access its internals
+        template<class A, class T, class O> friend class GridLoader;
 
     public:
 
@@ -59,7 +59,7 @@ class MANGOS_DLL_DECL Grid
         /** an object of interested enters the grid
          */
         template<class SPECIFIC_OBJECT>
-        bool AddWorldObject(SPECIFIC_OBJECT *obj)
+        bool AddWorldObject(SPECIFIC_OBJECT* obj)
         {
             return i_objects.template insert<SPECIFIC_OBJECT>(obj);
         }
@@ -67,7 +67,7 @@ class MANGOS_DLL_DECL Grid
         /** an object of interested exits the grid
          */
         template<class SPECIFIC_OBJECT>
-        bool RemoveWorldObject(SPECIFIC_OBJECT *obj)
+        bool RemoveWorldObject(SPECIFIC_OBJECT* obj)
         {
             return i_objects.template remove<SPECIFIC_OBJECT>(obj);
         }
@@ -75,7 +75,7 @@ class MANGOS_DLL_DECL Grid
         /** Grid visitor for grid objects
          */
         template<class T>
-        void Visit(TypeContainerVisitor<T, TypeMapContainer<GRID_OBJECT_TYPES> > &visitor)
+        void Visit(TypeContainerVisitor<T, TypeMapContainer<GRID_OBJECT_TYPES> >& visitor)
         {
             visitor.Visit(i_container);
         }
@@ -83,7 +83,7 @@ class MANGOS_DLL_DECL Grid
         /** Grid visitor for world objects
          */
         template<class T>
-        void Visit(TypeContainerVisitor<T, TypeMapContainer<WORLD_OBJECT_TYPES> > &visitor)
+        void Visit(TypeContainerVisitor<T, TypeMapContainer<WORLD_OBJECT_TYPES> >& visitor)
         {
             visitor.Visit(i_objects);
         }
@@ -98,7 +98,7 @@ class MANGOS_DLL_DECL Grid
         /** Inserts a container type object into the grid.
          */
         template<class SPECIFIC_OBJECT>
-        bool AddGridObject(SPECIFIC_OBJECT *obj)
+        bool AddGridObject(SPECIFIC_OBJECT* obj)
         {
             if (obj->isActiveObject())
                 m_activeGridObjects.insert(obj);
@@ -109,7 +109,7 @@ class MANGOS_DLL_DECL Grid
         /** Removes a containter type object from the grid
          */
         template<class SPECIFIC_OBJECT>
-        bool RemoveGridObject(SPECIFIC_OBJECT *obj)
+        bool RemoveGridObject(SPECIFIC_OBJECT* obj)
         {
             if (obj->isActiveObject())
                 m_activeGridObjects.erase(obj);
diff --git a/src/framework/GameSystem/GridLoader.h b/src/framework/GameSystem/GridLoader.h
index 7e9b58b2e..4a6d61073 100644
--- a/src/framework/GameSystem/GridLoader.h
+++ b/src/framework/GameSystem/GridLoader.h
@@ -37,9 +37,9 @@
 template
 <
 class ACTIVE_OBJECT,
-class WORLD_OBJECT_TYPES,
-class GRID_OBJECT_TYPES
->
+      class WORLD_OBJECT_TYPES,
+      class GRID_OBJECT_TYPES
+      >
 class MANGOS_DLL_DECL GridLoader
 {
     public:
@@ -47,7 +47,7 @@ class MANGOS_DLL_DECL GridLoader
         /** Loads the grid
          */
         template<class LOADER>
-        void Load(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, LOADER &loader)
+        void Load(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES>& grid, LOADER& loader)
         {
             loader.Load(grid);
         }
@@ -55,7 +55,7 @@ class MANGOS_DLL_DECL GridLoader
         /** Stop the grid
          */
         template<class STOPER>
-        void Stop(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, STOPER &stoper)
+        void Stop(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES>& grid, STOPER& stoper)
         {
             stoper.Stop(grid);
         }
@@ -63,7 +63,7 @@ class MANGOS_DLL_DECL GridLoader
         /** Unloads the grid
          */
         template<class UNLOADER>
-        void Unload(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, UNLOADER &unloader)
+        void Unload(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES>& grid, UNLOADER& unloader)
         {
             unloader.Unload(grid);
         }
diff --git a/src/framework/GameSystem/GridReference.h b/src/framework/GameSystem/GridReference.h
index 1c9fbe03b..6308c5925 100644
--- a/src/framework/GameSystem/GridReference.h
+++ b/src/framework/GameSystem/GridReference.h
@@ -60,7 +60,7 @@ class MANGOS_DLL_SPEC GridReference : public Reference<GridRefManager<OBJECT>, O
             this->unlink();
         }
 
-        GridReference *next()
+        GridReference* next()
         {
             return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next();
         }
diff --git a/src/framework/GameSystem/NGrid.h b/src/framework/GameSystem/NGrid.h
index d48458120..4848abd8d 100644
--- a/src/framework/GameSystem/NGrid.h
+++ b/src/framework/GameSystem/NGrid.h
@@ -37,7 +37,7 @@ class GridInfo
         {
         }
 
-        GridInfo(time_t expiry, bool unload = true )
+        GridInfo(time_t expiry, bool unload = true)
             : i_timer(expiry), i_unloadActiveLockCount(0), i_unloadExplicitLock(!unload)
         {
         }
@@ -49,7 +49,7 @@ class GridInfo
             return i_unloadActiveLockCount || i_unloadExplicitLock;
         }
 
-        void setUnloadExplicitLock( bool on ) { i_unloadExplicitLock = on; }
+        void setUnloadExplicitLock(bool on) { i_unloadExplicitLock = on; }
         void incUnloadActiveLock() { ++i_unloadActiveLockCount; }
         void decUnloadActiveLock() { if (i_unloadActiveLockCount) --i_unloadActiveLockCount; }
 
@@ -76,10 +76,10 @@ typedef enum
 template
 <
 uint32 N,
-class ACTIVE_OBJECT,
-class WORLD_OBJECT_TYPES,
-class GRID_OBJECT_TYPES
->
+       class ACTIVE_OBJECT,
+       class WORLD_OBJECT_TYPES,
+       class GRID_OBJECT_TYPES
+       >
 class MANGOS_DLL_DECL NGrid
 {
     public:
@@ -131,19 +131,19 @@ class MANGOS_DLL_DECL NGrid
         void UpdateTimeTracker(time_t diff) { i_GridInfo.UpdateTimeTracker(diff); }
 
         template<class SPECIFIC_OBJECT>
-        void AddWorldObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
+        void AddWorldObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT* obj)
         {
             getGridType(x, y).AddWorldObject(obj);
         }
 
         template<class SPECIFIC_OBJECT>
-        void RemoveWorldObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
+        void RemoveWorldObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT* obj)
         {
             getGridType(x, y).RemoveWorldObject(obj);
         }
 
         template<class T, class TT>
-        void Visit(TypeContainerVisitor<T, TypeMapContainer<TT> > &visitor)
+        void Visit(TypeContainerVisitor<T, TypeMapContainer<TT> >& visitor)
         {
             for (uint32 x = 0; x < N; ++x)
                 for (uint32 y = 0; y < N; ++y)
@@ -151,7 +151,7 @@ class MANGOS_DLL_DECL NGrid
         }
 
         template<class T, class TT>
-        void Visit(const uint32 &x, const uint32 &y, TypeContainerVisitor<T, TypeMapContainer<TT> > &visitor)
+        void Visit(const uint32& x, const uint32& y, TypeContainerVisitor<T, TypeMapContainer<TT> >& visitor)
         {
             getGridType(x, y).Visit(visitor);
         }
@@ -167,13 +167,13 @@ class MANGOS_DLL_DECL NGrid
         }
 
         template<class SPECIFIC_OBJECT>
-        bool AddGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
+        bool AddGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT* obj)
         {
             return getGridType(x, y).AddGridObject(obj);
         }
 
         template<class SPECIFIC_OBJECT>
-        bool RemoveGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
+        bool RemoveGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT* obj)
         {
             return getGridType(x, y).RemoveGridObject(obj);
         }
diff --git a/src/framework/GameSystem/TypeContainer.h b/src/framework/GameSystem/TypeContainer.h
index 45953f7f1..1f1a89eff 100644
--- a/src/framework/GameSystem/TypeContainer.h
+++ b/src/framework/GameSystem/TypeContainer.h
@@ -215,7 +215,7 @@ class MANGOS_DLL_DECL TypeMapContainer
 
         /// inserts a specific object into the container
         template<class SPECIFIC_TYPE>
-        bool insert(SPECIFIC_TYPE *obj)
+        bool insert(SPECIFIC_TYPE* obj)
         {
             SPECIFIC_TYPE* t = MaNGOS::Insert(i_elements, obj);
             return (t != NULL);
@@ -229,8 +229,8 @@ class MANGOS_DLL_DECL TypeMapContainer
             return (t != NULL);
         }
 
-        ContainerMapList<OBJECT_TYPES> & GetElements() { return i_elements; }
-        const ContainerMapList<OBJECT_TYPES> & GetElements() const { return i_elements;}
+        ContainerMapList<OBJECT_TYPES>& GetElements() { return i_elements; }
+        const ContainerMapList<OBJECT_TYPES>& GetElements() const { return i_elements;}
 
     private:
 
diff --git a/src/framework/GameSystem/TypeContainerFunctions.h b/src/framework/GameSystem/TypeContainerFunctions.h
index 117623822..6cd888b24 100644
--- a/src/framework/GameSystem/TypeContainerFunctions.h
+++ b/src/framework/GameSystem/TypeContainerFunctions.h
@@ -34,38 +34,38 @@ namespace MaNGOS
     /* ContainerMapList Helpers */
     // count functions
     template<class SPECIFIC_TYPE>
-    size_t Count(const ContainerMapList<SPECIFIC_TYPE> &elements, SPECIFIC_TYPE* /*fake*/)
+    size_t Count(const ContainerMapList<SPECIFIC_TYPE>& elements, SPECIFIC_TYPE* /*fake*/)
     {
         return elements._element.getSize();
     }
 
     template<class SPECIFIC_TYPE>
-    size_t Count(const ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE* /*fake*/)
+    size_t Count(const ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    size_t Count(const ContainerMapList<T> &/*elements*/, SPECIFIC_TYPE* /*fake*/)
+    size_t Count(const ContainerMapList<T>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    size_t Count(const ContainerMapList<TypeList<SPECIFIC_TYPE, T> >&elements, SPECIFIC_TYPE* fake)
+    size_t Count(const ContainerMapList<TypeList<SPECIFIC_TYPE, T> >& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._elements,fake);
     }
 
     template<class SPECIFIC_TYPE, class H, class T>
-    size_t Count(const ContainerMapList<TypeList<H, T> >&elements, SPECIFIC_TYPE* fake)
+    size_t Count(const ContainerMapList<TypeList<H, T> >& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._TailElements, fake);
     }
 
     // non-const insert functions
     template<class SPECIFIC_TYPE>
-    SPECIFIC_TYPE* Insert(ContainerMapList<SPECIFIC_TYPE> &elements, SPECIFIC_TYPE *obj)
+    SPECIFIC_TYPE* Insert(ContainerMapList<SPECIFIC_TYPE>& elements, SPECIFIC_TYPE* obj)
     {
         //elements._element[hdl] = obj;
         obj->GetGridRef().link(&elements._element, obj);
@@ -73,21 +73,21 @@ namespace MaNGOS
     }
 
     template<class SPECIFIC_TYPE>
-    SPECIFIC_TYPE* Insert(ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE * /*obj*/)
+    SPECIFIC_TYPE* Insert(ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
     {
         return NULL;
     }
 
     // this is a missed
     template<class SPECIFIC_TYPE, class T>
-    SPECIFIC_TYPE* Insert(ContainerMapList<T> &/*elements*/, SPECIFIC_TYPE * /*obj*/)
+    SPECIFIC_TYPE* Insert(ContainerMapList<T>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
     {
         return NULL;                                        // a missed
     }
 
     // Recursion
     template<class SPECIFIC_TYPE, class H, class T>
-    SPECIFIC_TYPE* Insert(ContainerMapList<TypeList<H, T> >&elements, SPECIFIC_TYPE *obj)
+    SPECIFIC_TYPE* Insert(ContainerMapList<TypeList<H, T> >& elements, SPECIFIC_TYPE* obj)
     {
         SPECIFIC_TYPE* t= Insert(elements._elements, obj);
         return (t != NULL ? t : Insert(elements._TailElements, obj));
@@ -95,31 +95,31 @@ namespace MaNGOS
 
     // non-const remove method
     template<class SPECIFIC_TYPE>
-    SPECIFIC_TYPE* Remove(ContainerMapList<SPECIFIC_TYPE> & /*elements*/, SPECIFIC_TYPE *obj)
+    SPECIFIC_TYPE* Remove(ContainerMapList<SPECIFIC_TYPE>& /*elements*/, SPECIFIC_TYPE* obj)
     {
         obj->GetGridRef().unlink();
         return obj;
     }
 
     template<class SPECIFIC_TYPE>
-    SPECIFIC_TYPE* Remove(ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE * /*obj*/)
+    SPECIFIC_TYPE* Remove(ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
     {
         return NULL;
     }
 
     // this is a missed
     template<class SPECIFIC_TYPE, class T>
-    SPECIFIC_TYPE* Remove(ContainerMapList<T> &/*elements*/, SPECIFIC_TYPE * /*obj*/)
+    SPECIFIC_TYPE* Remove(ContainerMapList<T>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
     {
         return NULL;                                        // a missed
     }
 
     template<class SPECIFIC_TYPE, class T, class H>
-    SPECIFIC_TYPE* Remove(ContainerMapList<TypeList<H, T> > &elements, SPECIFIC_TYPE *obj)
+    SPECIFIC_TYPE* Remove(ContainerMapList<TypeList<H, T> >& elements, SPECIFIC_TYPE* obj)
     {
         // The head element is bad
         SPECIFIC_TYPE* t = Remove(elements._elements, obj);
-        return ( t != NULL ? t : Remove(elements._TailElements, obj) );
+        return (t != NULL ? t : Remove(elements._TailElements, obj));
     }
 }
 
diff --git a/src/framework/GameSystem/TypeContainerFunctionsPtr.h b/src/framework/GameSystem/TypeContainerFunctionsPtr.h
index e660e0e30..96cbad7d7 100644
--- a/src/framework/GameSystem/TypeContainerFunctionsPtr.h
+++ b/src/framework/GameSystem/TypeContainerFunctionsPtr.h
@@ -59,84 +59,84 @@ namespace MaNGOS
     //    }
 
     // non-const find functions
-    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<SPECIFIC_TYPE> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<SPECIFIC_TYPE>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         typename std::map<OBJECT_HANDLE, CountedPtr<SPECIFIC_TYPE> >::iterator iter = elements._element.find(hdl);
         return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL) : iter->second);
     };
 
-    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<TypeNull> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<TypeNull>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);// terminate recursion
     }
 
-    template<class SPECIFIC_TYPE, class T> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<T> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE, class T> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<T>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);// this is a missed
     }
 
-    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<TypeList<H, T> >&elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
+    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<TypeList<H, T> >& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
     {
-        CountedPtr<SPECIFIC_TYPE> &t = Find(elements._elements, hdl,fake);
+        CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl,fake);
         return (!t ? Find(elements._TailElements, hdl,fake) : t);
     }
 
     // const find functions
-    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<SPECIFIC_TYPE> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<SPECIFIC_TYPE>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         typename CountedPtr<SPECIFIC_TYPE>::iterator iter = elements._element.find(hdl);
         return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL) : iter->second);
     };
 
-    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeNull> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeNull>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);
     }
 
-    template<class SPECIFIC_TYPE, class T> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<T> &elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE, class T> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<T>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);
     }
 
-    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeList<H, T> >&elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
+    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeList<H, T> >& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
     {
-        CountedPtr<SPECIFIC_TYPE> &t = Find(elements._elements, hdl,fake);
-        if(!t)
+        CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl,fake);
+        if (!t)
             t = Find(elements._TailElement, hdl,fake);
 
         return t;
     }
 
     // non-const insert functions
-    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<SPECIFIC_TYPE> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<SPECIFIC_TYPE>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         elements._element[hdl] = obj;
         return obj;
     };
 
-    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<TypeNull> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<TypeNull>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);
     }
 
     // this is a missed
-    template<class SPECIFIC_TYPE, class T> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<T> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE, class T> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<T>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);// a missed
     }
 
     // Recursion
-    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<TypeList<H, T> >&elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Insert(ContainerMapList<TypeList<H, T> >& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
-        CountedPtr<SPECIFIC_TYPE> &t= Insert(elements._elements, obj, hdl);
+        CountedPtr<SPECIFIC_TYPE>& t= Insert(elements._elements, obj, hdl);
         return (!t ? Insert(elements._TailElements, obj, hdl) : t);
     }
 
     // non-const remove method
-    template<class SPECIFIC_TYPE> bool Remove(ContainerMapList<SPECIFIC_TYPE> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE> bool Remove(ContainerMapList<SPECIFIC_TYPE>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         typename std::map<OBJECT_HANDLE, CountedPtr<SPECIFIC_TYPE> >::iterator iter = elements._element.find(hdl);
-        if( iter != elements._element.end() )
+        if (iter != elements._element.end())
         {
             elements._element.erase(iter);
             return true;
@@ -145,22 +145,22 @@ namespace MaNGOS
         return false;                                       // found... terminate the search
     }
 
-    template<class SPECIFIC_TYPE> bool Remove(ContainerMapList<TypeNull> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE> bool Remove(ContainerMapList<TypeNull>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         return false;
     }
 
     // this is a missed
-    template<class SPECIFIC_TYPE, class T> bool Remove(ContainerMapList<T> &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE, class T> bool Remove(ContainerMapList<T>& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         return false;
     }
 
-    template<class SPECIFIC_TYPE, class T, class H> bool Remove(ContainerMapList<TypeList<H, T> > &elements, CountedPtr<SPECIFIC_TYPE> &obj, OBJECT_HANDLE hdl)
+    template<class SPECIFIC_TYPE, class T, class H> bool Remove(ContainerMapList<TypeList<H, T> >& elements, CountedPtr<SPECIFIC_TYPE>& obj, OBJECT_HANDLE hdl)
     {
         // The head element is bad
         bool t = Remove(elements._elements, obj, hdl);
-        return ( !t ? Remove(elements._TailElements, obj, hdl) : t );
+        return (!t ? Remove(elements._TailElements, obj, hdl) : t);
     }
 
 }
diff --git a/src/framework/GameSystem/TypeContainerVisitor.h b/src/framework/GameSystem/TypeContainerVisitor.h
index 9130e16cf..1dfed6592 100644
--- a/src/framework/GameSystem/TypeContainerVisitor.h
+++ b/src/framework/GameSystem/TypeContainerVisitor.h
@@ -33,26 +33,26 @@ template<class T, class Y> class TypeContainerVisitor;
 
 // visitor helper
 template<class VISITOR, class TYPE_CONTAINER>
-void VisitorHelper(VISITOR &v, TYPE_CONTAINER &c)
+void VisitorHelper(VISITOR& v, TYPE_CONTAINER& c)
 {
     v.Visit(c);
 }
 
 // terminate condition container map list
 template<class VISITOR>
-void VisitorHelper(VISITOR &/*v*/, ContainerMapList<TypeNull> &/*c*/)
+void VisitorHelper(VISITOR& /*v*/, ContainerMapList<TypeNull>& /*c*/)
 {
 }
 
 template<class VISITOR, class T>
-void VisitorHelper(VISITOR &v, ContainerMapList<T> &c)
+void VisitorHelper(VISITOR& v, ContainerMapList<T>& c)
 {
     v.Visit(c._element);
 }
 
 // recursion container map list
 template<class VISITOR, class H, class T>
-void VisitorHelper(VISITOR &v, ContainerMapList<TypeList<H, T> > &c)
+void VisitorHelper(VISITOR& v, ContainerMapList<TypeList<H, T> >& c)
 {
     VisitorHelper(v, c._elements);
     VisitorHelper(v, c._TailElements);
@@ -60,7 +60,7 @@ void VisitorHelper(VISITOR &v, ContainerMapList<TypeList<H, T> > &c)
 
 // for TypeMapContainer
 template<class VISITOR, class OBJECT_TYPES>
-void VisitorHelper(VISITOR &v, TypeMapContainer<OBJECT_TYPES> &c)
+void VisitorHelper(VISITOR& v, TypeMapContainer<OBJECT_TYPES>& c)
 {
     VisitorHelper(v, c.GetElements());
 }
@@ -70,24 +70,24 @@ class MANGOS_DLL_DECL TypeContainerVisitor
 {
     public:
 
-        TypeContainerVisitor(VISITOR &v)
+        TypeContainerVisitor(VISITOR& v)
             : i_visitor(v)
         {
         }
 
-        void Visit(TYPE_CONTAINER &c)
+        void Visit(TYPE_CONTAINER& c)
         {
             VisitorHelper(i_visitor, c);
         }
 
-        void Visit(const TYPE_CONTAINER &c) const
+        void Visit(const TYPE_CONTAINER& c) const
         {
             VisitorHelper(i_visitor, c);
         }
 
     private:
 
-        VISITOR &i_visitor;
+        VISITOR& i_visitor;
 };
 
 #endif
diff --git a/src/framework/Policies/CreationPolicy.h b/src/framework/Policies/CreationPolicy.h
index 7e59dc82c..23dd0cdfb 100644
--- a/src/framework/Policies/CreationPolicy.h
+++ b/src/framework/Policies/CreationPolicy.h
@@ -37,7 +37,7 @@ namespace MaNGOS
                 return (new T);
             }
 
-            static void Destroy(T *obj)
+            static void Destroy(T* obj)
             {
                 delete obj;
             }
@@ -50,19 +50,19 @@ namespace MaNGOS
     template<class T>
     class MANGOS_DLL_DECL LocalStaticCreation
     {
-        union MaxAlign
-        {
-            char t_[sizeof(T)];
-            short int shortInt_;
-            int int_;
-            long int longInt_;
-            float float_;
-            double double_;
-            long double longDouble_;
-            struct Test;
-            int Test::* pMember_;
-            int (Test::*pMemberFn_)(int);
-        };
+            union MaxAlign
+            {
+                char t_[sizeof(T)];
+                short int shortInt_;
+                int int_;
+                long int longInt_;
+                float float_;
+                double double_;
+                long double longDouble_;
+                struct Test;
+                int Test::* pMember_;
+                int (Test::*pMemberFn_)(int);
+            };
 
         public:
 
@@ -72,7 +72,7 @@ namespace MaNGOS
                 return new(&si_localStatic) T;
             }
 
-            static void Destroy(T *obj)
+            static void Destroy(T* obj)
             {
                 obj->~T();
             }
@@ -115,7 +115,7 @@ namespace MaNGOS
                 return CALL_BACK::createCallBack();
             }
 
-            static void Destroy(T *p)
+            static void Destroy(T* p)
             {
                 CALL_BACK::destroyCallBack(p);
             }
diff --git a/src/framework/Policies/MemoryManagement.cpp b/src/framework/Policies/MemoryManagement.cpp
index 240158e93..9e2c36fad 100644
--- a/src/framework/Policies/MemoryManagement.cpp
+++ b/src/framework/Policies/MemoryManagement.cpp
@@ -24,7 +24,7 @@
 
 void* operator new(size_t sz)
 {
-    void *res = scalable_malloc(sz);
+    void* res = scalable_malloc(sz);
 
     if (res == NULL)
         throw std::bad_alloc();
@@ -34,7 +34,7 @@ void* operator new(size_t sz)
 
 void* operator new[](size_t sz)
 {
-    void *res = scalable_malloc(sz);
+    void* res = scalable_malloc(sz);
 
     if (res == NULL)
         throw std::bad_alloc();
diff --git a/src/framework/Policies/ObjectLifeTime.cpp b/src/framework/Policies/ObjectLifeTime.cpp
index bb1480e29..adf3b70c3 100644
--- a/src/framework/Policies/ObjectLifeTime.cpp
+++ b/src/framework/Policies/ObjectLifeTime.cpp
@@ -21,7 +21,7 @@
 
 namespace MaNGOS
 {
-    extern "C" void external_wrapper(void *p)
+    extern "C" void external_wrapper(void* p)
     {
         std::atexit((void (*)())p);
     }
diff --git a/src/framework/Policies/Singleton.h b/src/framework/Policies/Singleton.h
index bd4627ad4..09916ff29 100644
--- a/src/framework/Policies/Singleton.h
+++ b/src/framework/Policies/Singleton.h
@@ -32,10 +32,10 @@ namespace MaNGOS
     template
     <
     typename T,
-    class ThreadingModel = MaNGOS::SingleThreaded<T>,
-    class CreatePolicy = MaNGOS::OperatorNew<T>,
-    class LifeTimePolicy = MaNGOS::ObjectLifeTime<T>
-    >
+             class ThreadingModel = MaNGOS::SingleThreaded<T>,
+             class CreatePolicy = MaNGOS::OperatorNew<T>,
+             class LifeTimePolicy = MaNGOS::ObjectLifeTime<T>
+             >
     class MANGOS_DLL_DECL Singleton
     {
         public:
@@ -59,7 +59,7 @@ namespace MaNGOS
 
             // data structure
             typedef typename ThreadingModel::Lock Guard;
-            static T *si_instance;
+            static T* si_instance;
             static bool si_destroyed;
     };
 }
diff --git a/src/framework/Policies/SingletonImp.h b/src/framework/Policies/SingletonImp.h
index 1ec983be2..4a9628c71 100644
--- a/src/framework/Policies/SingletonImp.h
+++ b/src/framework/Policies/SingletonImp.h
@@ -27,10 +27,10 @@
 template
 <
 typename T,
-class ThreadingModel,
-class CreatePolicy,
-class LifeTimePolicy
->
+         class ThreadingModel,
+         class CreatePolicy,
+         class LifeTimePolicy
+         >
 T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance()
 {
     if (!si_instance)
@@ -57,10 +57,10 @@ T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance(
 template
 <
 typename T,
-class ThreadingModel,
-class CreatePolicy,
-class LifeTimePolicy
->
+         class ThreadingModel,
+         class CreatePolicy,
+         class LifeTimePolicy
+         >
 void MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingleton()
 {
     CreatePolicy::Destroy(si_instance);
diff --git a/src/framework/Policies/ThreadingModel.h b/src/framework/Policies/ThreadingModel.h
index 2f52424a4..f93f177b9 100644
--- a/src/framework/Policies/ThreadingModel.h
+++ b/src/framework/Policies/ThreadingModel.h
@@ -33,7 +33,7 @@ namespace MaNGOS
     {
         public:
 
-            GeneralLock(MUTEX &m)
+            GeneralLock(MUTEX& m)
                 : i_mutex(m)
             {
                 i_mutex.acquire();
@@ -46,9 +46,9 @@ namespace MaNGOS
 
         private:
 
-            GeneralLock(const GeneralLock &);
-            GeneralLock& operator=(const GeneralLock &);
-            MUTEX &i_mutex;
+            GeneralLock(const GeneralLock&);
+            GeneralLock& operator=(const GeneralLock&);
+            MUTEX& i_mutex;
     };
 
     template<class T>
@@ -87,7 +87,7 @@ namespace MaNGOS
             {
                 public:
 
-                    Lock(ObjectLevelLockable<T, MUTEX> &host)
+                    Lock(ObjectLevelLockable<T, MUTEX>& host)
                         : i_lock(host.i_mtx)
                     {
                     }
@@ -126,7 +126,7 @@ namespace MaNGOS
                         ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
                     }
 
-                    Lock(const ClassLevelLockable<T, MUTEX> &)
+                    Lock(const ClassLevelLockable<T, MUTEX>&)
                     {
                         ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
                     }
diff --git a/src/framework/Utilities/ByteConverter.h b/src/framework/Utilities/ByteConverter.h
index 74eb86572..1a1bbb2ed 100644
--- a/src/framework/Utilities/ByteConverter.h
+++ b/src/framework/Utilities/ByteConverter.h
@@ -29,19 +29,19 @@
 namespace ByteConverter
 {
     template<size_t T>
-    inline void convert(char *val)
+    inline void convert(char* val)
     {
         std::swap(*val, *(val + T - 1));
         convert<T - 2>(val + 1);
     }
 
-    template<> inline void convert<0>(char *) {}
-    template<> inline void convert<1>(char *) {}            // ignore central byte
+    template<> inline void convert<0>(char*) {}
+    template<> inline void convert<1>(char*) {}             // ignore central byte
 
     template<typename T>
-    inline void apply(T *val)
+    inline void apply(T* val)
     {
-        convert<sizeof(T)>((char *)(val));
+        convert<sizeof(T)>((char*)(val));
     }
 }
 
@@ -59,6 +59,6 @@ template<typename T> void EndianConvertReverse(T*);  // will generate link error
 inline void EndianConvert(uint8&) { }
 inline void EndianConvert(int8&)  { }
 inline void EndianConvertReverse(uint8&) { }
-inline void EndianConvertReverse( int8&) { }
+inline void EndianConvertReverse(int8&) { }
 
 #endif
diff --git a/src/framework/Utilities/Callback.h b/src/framework/Utilities/Callback.h
index 108f0e6ae..3f0238af3 100644
--- a/src/framework/Utilities/Callback.h
+++ b/src/framework/Utilities/Callback.h
@@ -54,7 +54,7 @@ namespace MaNGOS
         protected:
 
             typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
-            Class *m_object;
+            Class* m_object;
             Method m_method;
             ParamType1 m_param1;
             ParamType2 m_param2;
@@ -64,15 +64,15 @@ namespace MaNGOS
 
         public:
 
-            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
+            _Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
                 : m_object(object), m_method(method),
-                m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
+                  m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
             {
             }
 
             _Callback(_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
                 : m_object(cb.m_object), m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
             {
             }
     };
@@ -83,7 +83,7 @@ namespace MaNGOS
         protected:
 
             typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
-            Class *m_object;
+            Class* m_object;
             Method m_method;
             ParamType1 m_param1;
             ParamType2 m_param2;
@@ -91,15 +91,15 @@ namespace MaNGOS
             void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
 
         public:
-            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
+            _Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
                 : m_object(object), m_method(method),
-                m_param1(param1), m_param2(param2), m_param3(param3)
+                  m_param1(param1), m_param2(param2), m_param3(param3)
             {
             }
 
             _Callback(_Callback<Class, ParamType1, ParamType2, ParamType3> const& cb)
                 : m_object(cb.m_object), m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
             {
             }
     };
@@ -110,7 +110,7 @@ namespace MaNGOS
         protected:
 
             typedef void (Class::*Method)(ParamType1, ParamType2);
-            Class *m_object;
+            Class* m_object;
             Method m_method;
             ParamType1 m_param1;
             ParamType2 m_param2;
@@ -118,15 +118,15 @@ namespace MaNGOS
 
         public:
 
-            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2)
+            _Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2)
                 : m_object(object), m_method(method),
-                m_param1(param1), m_param2(param2)
+                  m_param1(param1), m_param2(param2)
             {
             }
 
             _Callback(_Callback<Class, ParamType1, ParamType2> const& cb)
                 : m_object(cb.m_object), m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2)
             {
             }
     };
@@ -137,22 +137,22 @@ namespace MaNGOS
         protected:
 
             typedef void (Class::*Method)(ParamType1);
-            Class *m_object;
+            Class* m_object;
             Method m_method;
             ParamType1 m_param1;
             void _Execute() { (m_object->*m_method)(m_param1); }
 
         public:
 
-            _Callback(Class *object, Method method, ParamType1 param1)
+            _Callback(Class* object, Method method, ParamType1 param1)
                 : m_object(object), m_method(method),
-                m_param1(param1)
+                  m_param1(param1)
             {
             }
 
             _Callback(_Callback<Class, ParamType1> const& cb)
                 : m_object(cb.m_object), m_method(cb.m_method),
-                m_param1(cb.m_param1)
+                  m_param1(cb.m_param1)
             {
             }
     };
@@ -163,12 +163,12 @@ namespace MaNGOS
         protected:
 
             typedef void (Class::*Method)();
-            Class *m_object;
+            Class* m_object;
             Method m_method;
             void _Execute() { (m_object->*m_method)(); }
 
         public:
-            _Callback(Class *object, Method method)
+            _Callback(Class* object, Method method)
                 : m_object(object), m_method(method)
             {
             }
@@ -197,13 +197,13 @@ namespace MaNGOS
 
             _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
                 : m_method(method),
-                m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
+                  m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
             {
             }
 
             _SCallback(_SCallback<ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
                 : m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
             {
             }
     };
@@ -223,12 +223,12 @@ namespace MaNGOS
         public:
             _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
                 : m_method(method),
-                m_param1(param1), m_param2(param2), m_param3(param3)
+                  m_param1(param1), m_param2(param2), m_param3(param3)
             {
             }
             _SCallback(_SCallback<ParamType1, ParamType2, ParamType3> const& cb)
                 : m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
             {
             }
     };
@@ -247,13 +247,13 @@ namespace MaNGOS
         public:
             _SCallback(Method method, ParamType1 param1, ParamType2 param2)
                 : m_method(method),
-                m_param1(param1), m_param2(param2)
+                  m_param1(param1), m_param2(param2)
             {
             }
 
             _SCallback(_SCallback<ParamType1, ParamType2> const& cb)
                 : m_method(cb.m_method),
-                m_param1(cb.m_param1), m_param2(cb.m_param2)
+                  m_param1(cb.m_param1), m_param2(cb.m_param2)
             {
             }
     };
@@ -271,13 +271,13 @@ namespace MaNGOS
         public:
             _SCallback(Method method, ParamType1 param1)
                 : m_method(method),
-                m_param1(param1)
+                  m_param1(param1)
             {
             }
 
             _SCallback(_SCallback<ParamType1> const& cb)
                 : m_method(cb.m_method),
-                m_param1(cb.m_param1)
+                  m_param1(cb.m_param1)
             {
             }
     };
@@ -337,7 +337,7 @@ namespace MaNGOS
             typedef _Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> C4;
         public:
 
-            Callback(Class *object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
+            Callback(Class* object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
                 : _ICallback<C4>(C4(object, method, param1, param2, param3, param4))
             {
             }
@@ -351,7 +351,7 @@ namespace MaNGOS
             typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3;
         public:
 
-            Callback(Class *object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
+            Callback(Class* object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
                 : _ICallback<C3>(C3(object, method, param1, param2, param3))
             {
             }
@@ -365,7 +365,7 @@ namespace MaNGOS
             typedef _Callback<Class, ParamType1, ParamType2> C2;
 
         public:
-            Callback(Class *object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
+            Callback(Class* object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
                 : _ICallback<C2>(C2(object, method, param1, param2))
             {
             }
@@ -380,7 +380,7 @@ namespace MaNGOS
 
         public:
 
-            Callback(Class *object, typename C1::Method method, ParamType1 param1)
+            Callback(Class* object, typename C1::Method method, ParamType1 param1)
                 : _ICallback<C1>(C1(object, method, param1))
             {
             }
@@ -395,7 +395,7 @@ namespace MaNGOS
 
         public:
 
-            Callback(Class *object, typename C0::Method method)
+            Callback(Class* object, typename C0::Method method)
                 : _ICallback<C0>(C0(object, method))
             {
             }
@@ -441,7 +441,7 @@ namespace MaNGOS
 
         public:
 
-            QueryCallback(Class *object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
+            QueryCallback(Class* object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
                 : _IQueryCallback<QC3>(QC3(object, method, result, param1, param2, param3))
             {
             }
@@ -456,7 +456,7 @@ namespace MaNGOS
 
         public:
 
-            QueryCallback(Class *object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
+            QueryCallback(Class* object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
                 : _IQueryCallback<QC2>(QC2(object, method, result, param1, param2))
             {
             }
@@ -471,7 +471,7 @@ namespace MaNGOS
 
         public:
 
-            QueryCallback(Class *object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
+            QueryCallback(Class* object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
                 : _IQueryCallback<QC1>(QC1(object, method, result, param1))
             {
             }
@@ -485,7 +485,7 @@ namespace MaNGOS
             typedef _Callback<Class, QueryResult*> QC0;
 
         public:
-            QueryCallback(Class *object, typename QC0::Method method, QueryResult* result)
+            QueryCallback(Class* object, typename QC0::Method method, QueryResult* result)
                 : _IQueryCallback<QC0>(QC0(object, method, result))
             {
             }
diff --git a/src/framework/Utilities/EventProcessor.cpp b/src/framework/Utilities/EventProcessor.cpp
index 62a873a49..27d6bf8dc 100644
--- a/src/framework/Utilities/EventProcessor.cpp
+++ b/src/framework/Utilities/EventProcessor.cpp
@@ -76,7 +76,7 @@ void EventProcessor::KillAllEvents(bool force)
             delete i_old->second;
 
             if (!force)                                      // need per-element cleanup
-                m_events.erase (i_old);
+                m_events.erase(i_old);
         }
     }
 
diff --git a/src/framework/Utilities/LinkedList.h b/src/framework/Utilities/LinkedList.h
index 5c472a45f..84f902b7d 100644
--- a/src/framework/Utilities/LinkedList.h
+++ b/src/framework/Utilities/LinkedList.h
@@ -42,14 +42,14 @@ class LinkedListElement
         bool hasPrev() const  { return (iPrev->iPrev != NULL); }
         bool isInList() const { return (iNext != NULL && iPrev != NULL); }
 
-        LinkedListElement      * next()       { return hasNext() ? iNext : NULL; }
+        LinkedListElement*       next()       { return hasNext() ? iNext : NULL; }
         LinkedListElement const* next() const { return hasNext() ? iNext : NULL; }
-        LinkedListElement      * prev()       { return hasPrev() ? iPrev : NULL; }
+        LinkedListElement*       prev()       { return hasPrev() ? iPrev : NULL; }
         LinkedListElement const* prev() const { return hasPrev() ? iPrev : NULL; }
 
-        LinkedListElement      * nocheck_next()       { return iNext; }
+        LinkedListElement*       nocheck_next()       { return iNext; }
         LinkedListElement const* nocheck_next() const { return iNext; }
-        LinkedListElement      * nocheck_prev()       { return iPrev; }
+        LinkedListElement*       nocheck_prev()       { return iPrev; }
         LinkedListElement const* nocheck_prev() const { return iPrev; }
 
         void delink()
@@ -103,10 +103,10 @@ class LinkedListHead
 
         bool isEmpty() const { return (!iFirst.iNext->isInList()); }
 
-        LinkedListElement      * getFirst()       { return (isEmpty() ? NULL : iFirst.iNext); }
+        LinkedListElement*       getFirst()       { return (isEmpty() ? NULL : iFirst.iNext); }
         LinkedListElement const* getFirst() const { return (isEmpty() ? NULL : iFirst.iNext); }
 
-        LinkedListElement      * getLast()        { return (isEmpty() ? NULL : iLast.iPrev); }
+        LinkedListElement*       getLast()        { return (isEmpty() ? NULL : iLast.iPrev); }
         LinkedListElement const* getLast() const  { return (isEmpty() ? NULL : iLast.iPrev); }
 
         void insertFirst(LinkedListElement* pElem)
@@ -126,7 +126,7 @@ class LinkedListHead
                 uint32 result = 0;
                 LinkedListElement const* e = getFirst();
 
-                while(e)
+                while (e)
                 {
                     ++result;
                     e = e->next();
@@ -158,93 +158,108 @@ class LinkedListHead
 
                 Iterator()
                     : _Ptr(0)
-                {                                           // construct with null node pointer
+                {
+                    // construct with null node pointer
                 }
 
                 Iterator(pointer _Pnode)
                     : _Ptr(_Pnode)
-                {                                           // construct with node pointer _Pnode
+                {
+                    // construct with node pointer _Pnode
                 }
 
-                Iterator& operator=(Iterator const &_Right)
+                Iterator& operator=(Iterator const& _Right)
                 {
                     return (*this) = _Right._Ptr;
                 }
 
-                Iterator& operator=(const_pointer const &_Right)
+                Iterator& operator=(const_pointer const& _Right)
                 {
                     _Ptr = (pointer)_Right;
                     return (*this);
                 }
 
                 reference operator*()
-                {                                           // return designated value
+                {
+                    // return designated value
                     return *_Ptr;
                 }
 
                 pointer operator->()
-                {                                           // return pointer to class object
+                {
+                    // return pointer to class object
                     return _Ptr;
                 }
 
                 Iterator& operator++()
-                {                                           // preincrement
+                {
+                    // preincrement
                     _Ptr = _Ptr->next();
                     return (*this);
                 }
 
                 Iterator operator++(int)
-                {                                           // postincrement
+                {
+                    // postincrement
                     iterator _Tmp = *this;
                     ++*this;
                     return (_Tmp);
                 }
 
                 Iterator& operator--()
-                {                                           // predecrement
+                {
+                    // predecrement
                     _Ptr = _Ptr->prev();
                     return (*this);
                 }
 
                 Iterator operator--(int)
-                {                                           // postdecrement
+                {
+                    // postdecrement
                     iterator _Tmp = *this;
                     --*this;
                     return (_Tmp);
                 }
 
-                bool operator==(Iterator const &_Right) const
-                {                                           // test for iterator equality
+                bool operator==(Iterator const& _Right) const
+                {
+                    // test for iterator equality
                     return (_Ptr == _Right._Ptr);
                 }
 
-                bool operator!=(Iterator const &_Right) const
-                {                                           // test for iterator inequality
+                bool operator!=(Iterator const& _Right) const
+                {
+                    // test for iterator inequality
                     return (!(*this == _Right));
                 }
 
-                bool operator==(pointer const &_Right) const
-                {                                           // test for pointer equality
+                bool operator==(pointer const& _Right) const
+                {
+                    // test for pointer equality
                     return (_Ptr != _Right);
                 }
 
-                bool operator!=(pointer const &_Right) const
-                {                                           // test for pointer equality
+                bool operator!=(pointer const& _Right) const
+                {
+                    // test for pointer equality
                     return (!(*this == _Right));
                 }
 
                 bool operator==(const_reference _Right) const
-                {                                           // test for reference equality
+                {
+                    // test for reference equality
                     return (_Ptr == &_Right);
                 }
 
                 bool operator!=(const_reference _Right) const
-                {                                           // test for reference equality
+                {
+                    // test for reference equality
                     return (_Ptr != &_Right);
                 }
 
                 pointer _Mynode()
-                {                                           // return node pointer
+                {
+                    // return node pointer
                     return (_Ptr);
                 }
 
diff --git a/src/framework/Utilities/LinkedReference/RefManager.h b/src/framework/Utilities/LinkedReference/RefManager.h
index c087a7038..bb42ce9b4 100644
--- a/src/framework/Utilities/LinkedReference/RefManager.h
+++ b/src/framework/Utilities/LinkedReference/RefManager.h
@@ -33,9 +33,9 @@ class RefManager : public LinkedListHead
         RefManager() {}
         virtual ~RefManager() { clearReferences(); }
 
-        Reference<TO, FROM>*       getFirst()       { return ((Reference<TO, FROM>      *) LinkedListHead::getFirst()); }
+        Reference<TO, FROM>*       getFirst()       { return ((Reference<TO, FROM>*) LinkedListHead::getFirst()); }
         Reference<TO, FROM> const* getFirst() const { return ((Reference<TO, FROM> const*) LinkedListHead::getFirst()); }
-        Reference<TO, FROM>*       getLast()       { return ((Reference<TO, FROM>      *) LinkedListHead::getLast()); }
+        Reference<TO, FROM>*       getLast()       { return ((Reference<TO, FROM>*) LinkedListHead::getLast()); }
         Reference<TO, FROM> const* getLast() const { return ((Reference<TO, FROM> const*) LinkedListHead::getLast()); }
 
         iterator begin() { return iterator(getFirst()); }
diff --git a/src/framework/Utilities/LinkedReference/Reference.h b/src/framework/Utilities/LinkedReference/Reference.h
index bd0b7e900..11859e1bb 100644
--- a/src/framework/Utilities/LinkedReference/Reference.h
+++ b/src/framework/Utilities/LinkedReference/Reference.h
@@ -90,14 +90,14 @@ class Reference : public LinkedListElement
             return iRefTo != NULL;
         }
 
-        Reference<TO,FROM>      * next()       { return((Reference<TO, FROM>      *) LinkedListElement::next()); }
+        Reference<TO,FROM>*       next()       { return((Reference<TO, FROM>*) LinkedListElement::next()); }
         Reference<TO,FROM> const* next() const { return((Reference<TO, FROM> const*) LinkedListElement::next()); }
-        Reference<TO,FROM>      * prev()       { return((Reference<TO, FROM>      *) LinkedListElement::prev()); }
+        Reference<TO,FROM>*       prev()       { return((Reference<TO, FROM>*) LinkedListElement::prev()); }
         Reference<TO,FROM> const* prev() const { return((Reference<TO, FROM> const*) LinkedListElement::prev()); }
 
-        Reference<TO,FROM>      * nocheck_next()       { return((Reference<TO, FROM>      *) LinkedListElement::nocheck_next()); }
+        Reference<TO,FROM>*       nocheck_next()       { return((Reference<TO, FROM>*) LinkedListElement::nocheck_next()); }
         Reference<TO,FROM> const* nocheck_next() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_next()); }
-        Reference<TO,FROM>      * nocheck_prev()       { return((Reference<TO, FROM>      *) LinkedListElement::nocheck_prev()); }
+        Reference<TO,FROM>*       nocheck_prev()       { return((Reference<TO, FROM>*) LinkedListElement::nocheck_prev()); }
         Reference<TO,FROM> const* nocheck_prev() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_prev()); }
 
         TO* operator->() const { return iRefTo; }
diff --git a/src/framework/Utilities/UnorderedMapSet.h b/src/framework/Utilities/UnorderedMapSet.h
index 0f4f1f195..9d4c060e7 100644
--- a/src/framework/Utilities/UnorderedMapSet.h
+++ b/src/framework/Utilities/UnorderedMapSet.h
@@ -73,7 +73,7 @@ template<class K>
 class hash
 {
     public:
-        size_t operator() (K const&);
+        size_t operator()(K const&);
 };
 
 HASH_NAMESPACE_END
@@ -100,27 +100,27 @@ using std::hash_set;
 
 HASH_NAMESPACE_START
 
-    template<>
-    class hash<unsigned long long>
-    {
-        public:
-            size_t operator()(const unsigned long long &__x) const { return (size_t)__x; }
-    };
+template<>
+class hash<unsigned long long>
+{
+    public:
+        size_t operator()(const unsigned long long& __x) const { return (size_t)__x; }
+};
 
-    template<typename T>
-    class hash<T *>
-    {
-        public:
-            size_t operator()(T * const &__x) const { return (size_t)__x; }
-    };
+template<typename T>
+class hash<T*>
+{
+    public:
+        size_t operator()(T* const& __x) const { return (size_t)__x; }
+};
 
-    template<> struct hash<std::string>
+template<> struct hash<std::string>
+{
+    size_t operator()(const std::string& __x) const
     {
-        size_t operator()(const std::string &__x) const
-        {
-            return hash<const char *>()(__x.c_str());
-        }
-    };
+        return hash<const char*>()(__x.c_str());
+    }
+};
 
 HASH_NAMESPACE_END