mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-13 13:37:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Various Cleanups (framework/)

Browse source
This commit is contained in:
Schmoozerd 2012-07-19 21:54:46 +02:00
parent 8951eed780
commit 9753625fd1
23 changed files with 239 additions and 224 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/framework/Dynamic/FactoryHolder.h
View file

@ -41,7 +41,7 @@ class MANGOS_DLL_DECL FactoryHolder
void DeregisterSelf(void) { FactoryHolderRepository::Instance().RemoveItem(this, false); } void DeregisterSelf(void) { FactoryHolderRepository::Instance().RemoveItem(this, false); }
/// Abstract Factory create method /// Abstract Factory create method
virtual T* Create(void *data = NULL) const = 0; virtual T* Create(void* data = NULL) const = 0;
private: private:
Key i_key; Key i_key;
}; };
@ -55,6 +55,6 @@ class Permissible
{ {
public: public:
virtual ~Permissible() {} virtual ~Permissible() {}
virtual int Permit(const T *) const = 0; virtual int Permit(const T*) const = 0;
}; };
#endif #endif

22
src/framework/Dynamic/ObjectRegistry.h
View file

@ -33,22 +33,22 @@ template<class T, class Key = std::string>
class MANGOS_DLL_DECL ObjectRegistry class MANGOS_DLL_DECL ObjectRegistry
{ {
public: public:
typedef std::map<Key, T *> RegistryMapType; typedef std::map<Key, T*> RegistryMapType;
/// Returns a registry item /// Returns a registry item
const T* GetRegistryItem(Key key) const const T* GetRegistryItem(Key key) const
{ {
typename RegistryMapType::const_iterator iter = i_registeredObjects.find(key); 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 /// 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); typename RegistryMapType::iterator iter = i_registeredObjects.find(key);
if( iter != i_registeredObjects.end() ) if (iter != i_registeredObjects.end())
{ {
if( !replace ) if (!replace)
return false; return false;
delete iter->second; delete iter->second;
i_registeredObjects.erase(iter); i_registeredObjects.erase(iter);
@ -62,9 +62,9 @@ class MANGOS_DLL_DECL ObjectRegistry
void RemoveItem(Key key, bool delete_object = true) void RemoveItem(Key key, bool delete_object = true)
{ {
typename RegistryMapType::iterator iter = i_registeredObjects.find(key); 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; delete iter->second;
i_registeredObjects.erase(iter); i_registeredObjects.erase(iter);
} }
@ -77,17 +77,17 @@ class MANGOS_DLL_DECL ObjectRegistry
} }
/// Inefficiently return a vector of registered items /// 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(); unsigned int sz = l.size();
l.resize(sz + i_registeredObjects.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; l[sz++] = iter->first;
return i_registeredObjects.size(); return i_registeredObjects.size();
} }
/// Return the map of registered items /// Return the map of registered items
RegistryMapType const &GetRegisteredItems() const RegistryMapType const& GetRegisteredItems() const
{ {
return i_registeredObjects; return i_registeredObjects;
} }
@ -100,7 +100,7 @@ class MANGOS_DLL_DECL ObjectRegistry
ObjectRegistry() {} 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; delete iter->second;
i_registeredObjects.clear(); i_registeredObjects.clear();
} }

22
src/framework/GameSystem/Grid.h
View file

@ -41,13 +41,13 @@ template<class A, class T, class O> class GridLoader;
template template
< <
class ACTIVE_OBJECT, class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES, class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES class GRID_OBJECT_TYPES
> >
class MANGOS_DLL_DECL Grid class MANGOS_DLL_DECL Grid
{ {
// allows the GridLoader to access its internals // allows the GridLoader to access its internals
template<class A, class T, class O> friend class GridLoader; template<class A, class T, class O> friend class GridLoader;
public: public:
@ -59,7 +59,7 @@ class MANGOS_DLL_DECL Grid
/** an object of interested enters the grid /** an object of interested enters the grid
*/ */
template<class SPECIFIC_OBJECT> template<class SPECIFIC_OBJECT>
bool AddWorldObject(SPECIFIC_OBJECT *obj) bool AddWorldObject(SPECIFIC_OBJECT* obj)
{ {
return i_objects.template insert<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 /** an object of interested exits the grid
*/ */
template<class SPECIFIC_OBJECT> template<class SPECIFIC_OBJECT>
bool RemoveWorldObject(SPECIFIC_OBJECT *obj) bool RemoveWorldObject(SPECIFIC_OBJECT* obj)
{ {
return i_objects.template remove<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 /** Grid visitor for grid objects
*/ */
template<class T> 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); visitor.Visit(i_container);
} }
@ -83,7 +83,7 @@ class MANGOS_DLL_DECL Grid
/** Grid visitor for world objects /** Grid visitor for world objects
*/ */
template<class T> 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); visitor.Visit(i_objects);
} }
@ -98,7 +98,7 @@ class MANGOS_DLL_DECL Grid
/** Inserts a container type object into the grid. /** Inserts a container type object into the grid.
*/ */
template<class SPECIFIC_OBJECT> template<class SPECIFIC_OBJECT>
bool AddGridObject(SPECIFIC_OBJECT *obj) bool AddGridObject(SPECIFIC_OBJECT* obj)
{ {
if (obj->isActiveObject()) if (obj->isActiveObject())
m_activeGridObjects.insert(obj); m_activeGridObjects.insert(obj);
@ -109,7 +109,7 @@ class MANGOS_DLL_DECL Grid
/** Removes a containter type object from the grid /** Removes a containter type object from the grid
*/ */
template<class SPECIFIC_OBJECT> template<class SPECIFIC_OBJECT>
bool RemoveGridObject(SPECIFIC_OBJECT *obj) bool RemoveGridObject(SPECIFIC_OBJECT* obj)
{ {
if (obj->isActiveObject()) if (obj->isActiveObject())
m_activeGridObjects.erase(obj); m_activeGridObjects.erase(obj);

12
src/framework/GameSystem/GridLoader.h
View file

@ -37,9 +37,9 @@
template template
< <
class ACTIVE_OBJECT, class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES, class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES class GRID_OBJECT_TYPES
> >
class MANGOS_DLL_DECL GridLoader class MANGOS_DLL_DECL GridLoader
{ {
public: public:
@ -47,7 +47,7 @@ class MANGOS_DLL_DECL GridLoader
/** Loads the grid /** Loads the grid
*/ */
template<class LOADER> 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); loader.Load(grid);
} }
@ -55,7 +55,7 @@ class MANGOS_DLL_DECL GridLoader
/** Stop the grid /** Stop the grid
*/ */
template<class STOPER> 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); stoper.Stop(grid);
} }
@ -63,7 +63,7 @@ class MANGOS_DLL_DECL GridLoader
/** Unloads the grid /** Unloads the grid
*/ */
template<class UNLOADER> 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); unloader.Unload(grid);
} }

2
src/framework/GameSystem/GridReference.h
View file

@ -60,7 +60,7 @@ class MANGOS_DLL_SPEC GridReference : public Reference<GridRefManager<OBJECT>, O
this->unlink(); this->unlink();
} }
GridReference *next() GridReference* next()
{ {
return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next(); return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next();
} }

24
src/framework/GameSystem/NGrid.h
View file

@ -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) : i_timer(expiry), i_unloadActiveLockCount(0), i_unloadExplicitLock(!unload)
{ {
} }
@ -49,7 +49,7 @@ class GridInfo
return i_unloadActiveLockCount || i_unloadExplicitLock; return i_unloadActiveLockCount || i_unloadExplicitLock;
} }
void setUnloadExplicitLock( bool on ) { i_unloadExplicitLock = on; } void setUnloadExplicitLock(bool on) { i_unloadExplicitLock = on; }
void incUnloadActiveLock() { ++i_unloadActiveLockCount; } void incUnloadActiveLock() { ++i_unloadActiveLockCount; }
void decUnloadActiveLock() { if (i_unloadActiveLockCount) --i_unloadActiveLockCount; } void decUnloadActiveLock() { if (i_unloadActiveLockCount) --i_unloadActiveLockCount; }
@ -76,10 +76,10 @@ typedef enum
template template
< <
uint32 N, uint32 N,
class ACTIVE_OBJECT, class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES, class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES class GRID_OBJECT_TYPES
> >
class MANGOS_DLL_DECL NGrid class MANGOS_DLL_DECL NGrid
{ {
public: public:
@ -131,19 +131,19 @@ class MANGOS_DLL_DECL NGrid
void UpdateTimeTracker(time_t diff) { i_GridInfo.UpdateTimeTracker(diff); } void UpdateTimeTracker(time_t diff) { i_GridInfo.UpdateTimeTracker(diff); }
template<class SPECIFIC_OBJECT> 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); getGridType(x, y).AddWorldObject(obj);
} }
template<class SPECIFIC_OBJECT> 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); getGridType(x, y).RemoveWorldObject(obj);
} }
template<class T, class TT> 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 x = 0; x < N; ++x)
for (uint32 y = 0; y < N; ++y) for (uint32 y = 0; y < N; ++y)
@ -151,7 +151,7 @@ class MANGOS_DLL_DECL NGrid
} }
template<class T, class TT> 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); getGridType(x, y).Visit(visitor);
} }
@ -167,13 +167,13 @@ class MANGOS_DLL_DECL NGrid
} }
template<class SPECIFIC_OBJECT> 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); return getGridType(x, y).AddGridObject(obj);
} }
template<class SPECIFIC_OBJECT> 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); return getGridType(x, y).RemoveGridObject(obj);
} }

6
src/framework/GameSystem/TypeContainer.h
View file

@ -215,7 +215,7 @@ class MANGOS_DLL_DECL TypeMapContainer
/// inserts a specific object into the container /// inserts a specific object into the container
template<class SPECIFIC_TYPE> template<class SPECIFIC_TYPE>
bool insert(SPECIFIC_TYPE *obj) bool insert(SPECIFIC_TYPE* obj)
{ {
SPECIFIC_TYPE* t = MaNGOS::Insert(i_elements, obj); SPECIFIC_TYPE* t = MaNGOS::Insert(i_elements, obj);
return (t != NULL); return (t != NULL);
@ -229,8 +229,8 @@ class MANGOS_DLL_DECL TypeMapContainer
return (t != NULL); return (t != NULL);
} }
ContainerMapList<OBJECT_TYPES> & GetElements() { return i_elements; } ContainerMapList<OBJECT_TYPES>& GetElements() { return i_elements; }
const ContainerMapList<OBJECT_TYPES> & GetElements() const { return i_elements;} const ContainerMapList<OBJECT_TYPES>& GetElements() const { return i_elements;}
private: private:

28
src/framework/GameSystem/TypeContainerFunctions.h
View file

@ -34,38 +34,38 @@ namespace MaNGOS
/* ContainerMapList Helpers */ /* ContainerMapList Helpers */
// count functions // count functions
template<class SPECIFIC_TYPE> 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(); return elements._element.getSize();
} }
template<class SPECIFIC_TYPE> 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; return 0;
} }
template<class SPECIFIC_TYPE, class T> 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; return 0;
} }
template<class SPECIFIC_TYPE, class T> 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); return Count(elements._elements,fake);
} }
template<class SPECIFIC_TYPE, class H, class T> 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); return Count(elements._TailElements, fake);
} }
// non-const insert functions // non-const insert functions
template<class SPECIFIC_TYPE> 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; //elements._element[hdl] = obj;
obj->GetGridRef().link(&elements._element, obj); obj->GetGridRef().link(&elements._element, obj);
@ -73,21 +73,21 @@ namespace MaNGOS
} }
template<class SPECIFIC_TYPE> template<class SPECIFIC_TYPE>
SPECIFIC_TYPE* Insert(ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE * /*obj*/) SPECIFIC_TYPE* Insert(ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
{ {
return NULL; return NULL;
} }
// this is a missed // this is a missed
template<class SPECIFIC_TYPE, class T> 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 return NULL; // a missed
} }
// Recursion // Recursion
template<class SPECIFIC_TYPE, class H, class T> 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); SPECIFIC_TYPE* t= Insert(elements._elements, obj);
return (t != NULL ? t : Insert(elements._TailElements, obj)); return (t != NULL ? t : Insert(elements._TailElements, obj));
@ -95,31 +95,31 @@ namespace MaNGOS
// non-const remove method // non-const remove method
template<class SPECIFIC_TYPE> 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(); obj->GetGridRef().unlink();
return obj; return obj;
} }
template<class SPECIFIC_TYPE> template<class SPECIFIC_TYPE>
SPECIFIC_TYPE* Remove(ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE * /*obj*/) SPECIFIC_TYPE* Remove(ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*obj*/)
{ {
return NULL; return NULL;
} }
// this is a missed // this is a missed
template<class SPECIFIC_TYPE, class T> 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 return NULL; // a missed
} }
template<class SPECIFIC_TYPE, class T, class H> 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 // The head element is bad
SPECIFIC_TYPE* t = Remove(elements._elements, obj); SPECIFIC_TYPE* t = Remove(elements._elements, obj);
return ( t != NULL ? t : Remove(elements._TailElements, obj) ); return (t != NULL ? t : Remove(elements._TailElements, obj));
} }
} }

44
src/framework/GameSystem/TypeContainerFunctionsPtr.h
View file

@ -59,84 +59,84 @@ namespace MaNGOS
// } // }
// non-const find functions // 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); 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); 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 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 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); return (!t ? Find(elements._TailElements, hdl,fake) : t);
} }
// const find functions // 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); typename CountedPtr<SPECIFIC_TYPE>::iterator iter = elements._element.find(hdl);
return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL) : iter->second); 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); 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); 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); CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl,fake);
if(!t) if (!t)
t = Find(elements._TailElement, hdl,fake); t = Find(elements._TailElement, hdl,fake);
return t; return t;
} }
// non-const insert functions // 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; elements._element[hdl] = obj;
return 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); return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);
} }
// this is a missed // 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 return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)NULL);// a missed
} }
// Recursion // 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); return (!t ? Insert(elements._TailElements, obj, hdl) : t);
} }
// non-const remove method // 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); 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); elements._element.erase(iter);
return true; return true;
@ -145,22 +145,22 @@ namespace MaNGOS
return false; // found... terminate the search 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; return false;
} }
// this is a missed // 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; 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 // The head element is bad
bool t = Remove(elements._elements, obj, hdl); bool t = Remove(elements._elements, obj, hdl);
return ( !t ? Remove(elements._TailElements, obj, hdl) : t ); return (!t ? Remove(elements._TailElements, obj, hdl) : t);
} }
} }

18
src/framework/GameSystem/TypeContainerVisitor.h
View file

@ -33,26 +33,26 @@ template<class T, class Y> class TypeContainerVisitor;
// visitor helper // visitor helper
template<class VISITOR, class TYPE_CONTAINER> template<class VISITOR, class TYPE_CONTAINER>
void VisitorHelper(VISITOR &v, TYPE_CONTAINER &c) void VisitorHelper(VISITOR& v, TYPE_CONTAINER& c)
{ {
v.Visit(c); v.Visit(c);
} }
// terminate condition container map list // terminate condition container map list
template<class VISITOR> template<class VISITOR>
void VisitorHelper(VISITOR &/*v*/, ContainerMapList<TypeNull> &/*c*/) void VisitorHelper(VISITOR& /*v*/, ContainerMapList<TypeNull>& /*c*/)
{ {
} }
template<class VISITOR, class T> template<class VISITOR, class T>
void VisitorHelper(VISITOR &v, ContainerMapList<T> &c) void VisitorHelper(VISITOR& v, ContainerMapList<T>& c)
{ {
v.Visit(c._element); v.Visit(c._element);
} }
// recursion container map list // recursion container map list
template<class VISITOR, class H, class T> 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._elements);
VisitorHelper(v, c._TailElements); VisitorHelper(v, c._TailElements);
@ -60,7 +60,7 @@ void VisitorHelper(VISITOR &v, ContainerMapList<TypeList<H, T> > &c)
// for TypeMapContainer // for TypeMapContainer
template<class VISITOR, class OBJECT_TYPES> 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()); VisitorHelper(v, c.GetElements());
} }
@ -70,24 +70,24 @@ class MANGOS_DLL_DECL TypeContainerVisitor
{ {
public: public:
TypeContainerVisitor(VISITOR &v) TypeContainerVisitor(VISITOR& v)
: i_visitor(v) : i_visitor(v)
{ {
} }
void Visit(TYPE_CONTAINER &c) void Visit(TYPE_CONTAINER& c)
{ {
VisitorHelper(i_visitor, c); VisitorHelper(i_visitor, c);
} }
void Visit(const TYPE_CONTAINER &c) const void Visit(const TYPE_CONTAINER& c) const
{ {
VisitorHelper(i_visitor, c); VisitorHelper(i_visitor, c);
} }
private: private:
VISITOR &i_visitor; VISITOR& i_visitor;
}; };
#endif #endif

32
src/framework/Policies/CreationPolicy.h
View file

@ -37,7 +37,7 @@ namespace MaNGOS
return (new T); return (new T);
} }
static void Destroy(T *obj) static void Destroy(T* obj)
{ {
delete obj; delete obj;
} }
@ -50,19 +50,19 @@ namespace MaNGOS
template<class T> template<class T>
class MANGOS_DLL_DECL LocalStaticCreation class MANGOS_DLL_DECL LocalStaticCreation
{ {
union MaxAlign union MaxAlign
{ {
char t_[sizeof(T)]; char t_[sizeof(T)];
short int shortInt_; short int shortInt_;
int int_; int int_;
long int longInt_; long int longInt_;
float float_; float float_;
double double_; double double_;
long double longDouble_; long double longDouble_;
struct Test; struct Test;
int Test::* pMember_; int Test::* pMember_;
int (Test::*pMemberFn_)(int); int (Test::*pMemberFn_)(int);
}; };
public: public:
@ -72,7 +72,7 @@ namespace MaNGOS
return new(&si_localStatic) T; return new(&si_localStatic) T;
} }
static void Destroy(T *obj) static void Destroy(T* obj)
{ {
obj->~T(); obj->~T();
} }
@ -115,7 +115,7 @@ namespace MaNGOS
return CALL_BACK::createCallBack(); return CALL_BACK::createCallBack();
} }
static void Destroy(T *p) static void Destroy(T* p)
{ {
CALL_BACK::destroyCallBack(p); CALL_BACK::destroyCallBack(p);
} }

4
src/framework/Policies/MemoryManagement.cpp
View file

@ -24,7 +24,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) if (res == NULL)
throw std::bad_alloc(); throw std::bad_alloc();
@ -34,7 +34,7 @@ void* operator new(size_t sz)
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) if (res == NULL)
throw std::bad_alloc(); throw std::bad_alloc();

2
src/framework/Policies/ObjectLifeTime.cpp
View file

@ -21,7 +21,7 @@
namespace MaNGOS namespace MaNGOS
{ {
extern "C" void external_wrapper(void *p) extern "C" void external_wrapper(void* p)
{ {
std::atexit((void (*)())p); std::atexit((void (*)())p);
} }

10
src/framework/Policies/Singleton.h
View file

@ -32,10 +32,10 @@ namespace MaNGOS
template template
< <
typename T, typename T,
class ThreadingModel = MaNGOS::SingleThreaded<T>, class ThreadingModel = MaNGOS::SingleThreaded<T>,
class CreatePolicy = MaNGOS::OperatorNew<T>, class CreatePolicy = MaNGOS::OperatorNew<T>,
class LifeTimePolicy = MaNGOS::ObjectLifeTime<T> class LifeTimePolicy = MaNGOS::ObjectLifeTime<T>
> >
class MANGOS_DLL_DECL Singleton class MANGOS_DLL_DECL Singleton
{ {
public: public:
@ -59,7 +59,7 @@ namespace MaNGOS
// data structure // data structure
typedef typename ThreadingModel::Lock Guard; typedef typename ThreadingModel::Lock Guard;
static T *si_instance; static T* si_instance;
static bool si_destroyed; static bool si_destroyed;
}; };
} }

16
src/framework/Policies/SingletonImp.h
View file

@ -27,10 +27,10 @@
template template
< <
typename T, typename T,
class ThreadingModel, class ThreadingModel,
class CreatePolicy, class CreatePolicy,
class LifeTimePolicy class LifeTimePolicy
> >
T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance() T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance()
{ {
if (!si_instance) if (!si_instance)
@ -57,10 +57,10 @@ T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance(
template template
< <
typename T, typename T,
class ThreadingModel, class ThreadingModel,
class CreatePolicy, class CreatePolicy,
class LifeTimePolicy class LifeTimePolicy
> >
void MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingleton() void MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingleton()
{ {
CreatePolicy::Destroy(si_instance); CreatePolicy::Destroy(si_instance);

12
src/framework/Policies/ThreadingModel.h
View file

@ -33,7 +33,7 @@ namespace MaNGOS
{ {
public: public:
GeneralLock(MUTEX &m) GeneralLock(MUTEX& m)
: i_mutex(m) : i_mutex(m)
{ {
i_mutex.acquire(); i_mutex.acquire();
@ -46,9 +46,9 @@ namespace MaNGOS
private: private:
GeneralLock(const GeneralLock &); GeneralLock(const GeneralLock&);
GeneralLock& operator=(const GeneralLock &); GeneralLock& operator=(const GeneralLock&);
MUTEX &i_mutex; MUTEX& i_mutex;
}; };
template<class T> template<class T>
@ -87,7 +87,7 @@ namespace MaNGOS
{ {
public: public:
Lock(ObjectLevelLockable<T, MUTEX> &host) Lock(ObjectLevelLockable<T, MUTEX>& host)
: i_lock(host.i_mtx) : i_lock(host.i_mtx)
{ {
} }
@ -126,7 +126,7 @@ namespace MaNGOS
ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
} }
Lock(const ClassLevelLockable<T, MUTEX> &) Lock(const ClassLevelLockable<T, MUTEX>&)
{ {
ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
} }

12
src/framework/Utilities/ByteConverter.h
View file

@ -29,19 +29,19 @@
namespace ByteConverter namespace ByteConverter
{ {
template<size_t T> template<size_t T>
inline void convert(char *val) inline void convert(char* val)
{ {
std::swap(*val, *(val + T - 1)); std::swap(*val, *(val + T - 1));
convert<T - 2>(val + 1); convert<T - 2>(val + 1);
} }
template<> inline void convert<0>(char *) {} template<> inline void convert<0>(char*) {}
template<> inline void convert<1>(char *) {} // ignore central byte template<> inline void convert<1>(char*) {} // ignore central byte
template<typename T> 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(uint8&) { }
inline void EndianConvert(int8&) { } inline void EndianConvert(int8&) { }
inline void EndianConvertReverse(uint8&) { } inline void EndianConvertReverse(uint8&) { }
inline void EndianConvertReverse( int8&) { } inline void EndianConvertReverse(int8&) { }
#endif #endif

70
src/framework/Utilities/Callback.h
View file

@ -54,7 +54,7 @@ namespace MaNGOS
protected: protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4); typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
Class *m_object; Class* m_object;
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
ParamType2 m_param2; ParamType2 m_param2;
@ -64,15 +64,15 @@ namespace MaNGOS
public: 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_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) _Callback(_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
: m_object(cb.m_object), m_method(cb.m_method), : 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: protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3); typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
Class *m_object; Class* m_object;
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
ParamType2 m_param2; ParamType2 m_param2;
@ -91,15 +91,15 @@ namespace MaNGOS
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); } void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
public: 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_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) _Callback(_Callback<Class, ParamType1, ParamType2, ParamType3> const& cb)
: m_object(cb.m_object), m_method(cb.m_method), : 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: protected:
typedef void (Class::*Method)(ParamType1, ParamType2); typedef void (Class::*Method)(ParamType1, ParamType2);
Class *m_object; Class* m_object;
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
ParamType2 m_param2; ParamType2 m_param2;
@ -118,15 +118,15 @@ namespace MaNGOS
public: 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_object(object), m_method(method),
m_param1(param1), m_param2(param2) m_param1(param1), m_param2(param2)
{ {
} }
_Callback(_Callback<Class, ParamType1, ParamType2> const& cb) _Callback(_Callback<Class, ParamType1, ParamType2> const& cb)
: m_object(cb.m_object), m_method(cb.m_method), : 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: protected:
typedef void (Class::*Method)(ParamType1); typedef void (Class::*Method)(ParamType1);
Class *m_object; Class* m_object;
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
void _Execute() { (m_object->*m_method)(m_param1); } void _Execute() { (m_object->*m_method)(m_param1); }
public: public:
_Callback(Class *object, Method method, ParamType1 param1) _Callback(Class* object, Method method, ParamType1 param1)
: m_object(object), m_method(method), : m_object(object), m_method(method),
m_param1(param1) m_param1(param1)
{ {
} }
_Callback(_Callback<Class, ParamType1> const& cb) _Callback(_Callback<Class, ParamType1> const& cb)
: m_object(cb.m_object), m_method(cb.m_method), : 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: protected:
typedef void (Class::*Method)(); typedef void (Class::*Method)();
Class *m_object; Class* m_object;
Method m_method; Method m_method;
void _Execute() { (m_object->*m_method)(); } void _Execute() { (m_object->*m_method)(); }
public: public:
_Callback(Class *object, Method method) _Callback(Class* object, Method method)
: m_object(object), m_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) _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
: m_method(method), : 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) _SCallback(_SCallback<ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
: m_method(cb.m_method), : 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: public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3) _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_method(method), : 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) _SCallback(_SCallback<ParamType1, ParamType2, ParamType3> const& cb)
: m_method(cb.m_method), : 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: public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2) _SCallback(Method method, ParamType1 param1, ParamType2 param2)
: m_method(method), : m_method(method),
m_param1(param1), m_param2(param2) m_param1(param1), m_param2(param2)
{ {
} }
_SCallback(_SCallback<ParamType1, ParamType2> const& cb) _SCallback(_SCallback<ParamType1, ParamType2> const& cb)
: m_method(cb.m_method), : 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: public:
_SCallback(Method method, ParamType1 param1) _SCallback(Method method, ParamType1 param1)
: m_method(method), : m_method(method),
m_param1(param1) m_param1(param1)
{ {
} }
_SCallback(_SCallback<ParamType1> const& cb) _SCallback(_SCallback<ParamType1> const& cb)
: m_method(cb.m_method), : 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; typedef _Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> C4;
public: 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)) : _ICallback<C4>(C4(object, method, param1, param2, param3, param4))
{ {
} }
@ -351,7 +351,7 @@ namespace MaNGOS
typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3; typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3;
public: 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)) : _ICallback<C3>(C3(object, method, param1, param2, param3))
{ {
} }
@ -365,7 +365,7 @@ namespace MaNGOS
typedef _Callback<Class, ParamType1, ParamType2> C2; typedef _Callback<Class, ParamType1, ParamType2> C2;
public: 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)) : _ICallback<C2>(C2(object, method, param1, param2))
{ {
} }
@ -380,7 +380,7 @@ namespace MaNGOS
public: 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)) : _ICallback<C1>(C1(object, method, param1))
{ {
} }
@ -395,7 +395,7 @@ namespace MaNGOS
public: public:
Callback(Class *object, typename C0::Method method) Callback(Class* object, typename C0::Method method)
: _ICallback<C0>(C0(object, method)) : _ICallback<C0>(C0(object, method))
{ {
} }
@ -441,7 +441,7 @@ namespace MaNGOS
public: 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)) : _IQueryCallback<QC3>(QC3(object, method, result, param1, param2, param3))
{ {
} }
@ -456,7 +456,7 @@ namespace MaNGOS
public: 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)) : _IQueryCallback<QC2>(QC2(object, method, result, param1, param2))
{ {
} }
@ -471,7 +471,7 @@ namespace MaNGOS
public: 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)) : _IQueryCallback<QC1>(QC1(object, method, result, param1))
{ {
} }
@ -485,7 +485,7 @@ namespace MaNGOS
typedef _Callback<Class, QueryResult*> QC0; typedef _Callback<Class, QueryResult*> QC0;
public: 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)) : _IQueryCallback<QC0>(QC0(object, method, result))
{ {
} }

2
src/framework/Utilities/EventProcessor.cpp
View file

@ -76,7 +76,7 @@ void EventProcessor::KillAllEvents(bool force)
delete i_old->second; delete i_old->second;
if (!force) // need per-element cleanup if (!force) // need per-element cleanup
m_events.erase (i_old); m_events.erase(i_old);
} }
} }

71
src/framework/Utilities/LinkedList.h
View file

@ -42,14 +42,14 @@ class LinkedListElement
bool hasPrev() const { return (iPrev->iPrev != NULL); } bool hasPrev() const { return (iPrev->iPrev != NULL); }
bool isInList() const { return (iNext != NULL && 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 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 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 const* nocheck_next() const { return iNext; }
LinkedListElement * nocheck_prev() { return iPrev; } LinkedListElement* nocheck_prev() { return iPrev; }
LinkedListElement const* nocheck_prev() const { return iPrev; } LinkedListElement const* nocheck_prev() const { return iPrev; }
void delink() void delink()
@ -103,10 +103,10 @@ class LinkedListHead
bool isEmpty() const { return (!iFirst.iNext->isInList()); } 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 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); } LinkedListElement const* getLast() const { return (isEmpty() ? NULL : iLast.iPrev); }
void insertFirst(LinkedListElement* pElem) void insertFirst(LinkedListElement* pElem)
@ -126,7 +126,7 @@ class LinkedListHead
uint32 result = 0; uint32 result = 0;
LinkedListElement const* e = getFirst(); LinkedListElement const* e = getFirst();
while(e) while (e)
{ {
++result; ++result;
e = e->next(); e = e->next();
@ -158,93 +158,108 @@ class LinkedListHead
Iterator() Iterator()
: _Ptr(0) : _Ptr(0)
{ // construct with null node pointer {
// construct with null node pointer
} }
Iterator(pointer _Pnode) Iterator(pointer _Pnode)
: _Ptr(_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; return (*this) = _Right._Ptr;
} }
Iterator& operator=(const_pointer const &_Right) Iterator& operator=(const_pointer const& _Right)
{ {
_Ptr = (pointer)_Right; _Ptr = (pointer)_Right;
return (*this); return (*this);
} }
reference operator*() reference operator*()
{ // return designated value {
// return designated value
return *_Ptr; return *_Ptr;
} }
pointer operator->() pointer operator->()
{ // return pointer to class object {
// return pointer to class object
return _Ptr; return _Ptr;
} }
Iterator& operator++() Iterator& operator++()
{ // preincrement {
// preincrement
_Ptr = _Ptr->next(); _Ptr = _Ptr->next();
return (*this); return (*this);
} }
Iterator operator++(int) Iterator operator++(int)
{ // postincrement {
// postincrement
iterator _Tmp = *this; iterator _Tmp = *this;
++*this; ++*this;
return (_Tmp); return (_Tmp);
} }
Iterator& operator--() Iterator& operator--()
{ // predecrement {
// predecrement
_Ptr = _Ptr->prev(); _Ptr = _Ptr->prev();
return (*this); return (*this);
} }
Iterator operator--(int) Iterator operator--(int)
{ // postdecrement {
// postdecrement
iterator _Tmp = *this; iterator _Tmp = *this;
--*this; --*this;
return (_Tmp); return (_Tmp);
} }
bool operator==(Iterator const &_Right) const bool operator==(Iterator const& _Right) const
{ // test for iterator equality {
// test for iterator equality
return (_Ptr == _Right._Ptr); return (_Ptr == _Right._Ptr);
} }
bool operator!=(Iterator const &_Right) const bool operator!=(Iterator const& _Right) const
{ // test for iterator inequality {
// test for iterator inequality
return (!(*this == _Right)); return (!(*this == _Right));
} }
bool operator==(pointer const &_Right) const bool operator==(pointer const& _Right) const
{ // test for pointer equality {
// test for pointer equality
return (_Ptr != _Right); return (_Ptr != _Right);
} }
bool operator!=(pointer const &_Right) const bool operator!=(pointer const& _Right) const
{ // test for pointer equality {
// test for pointer equality
return (!(*this == _Right)); return (!(*this == _Right));
} }
bool operator==(const_reference _Right) const bool operator==(const_reference _Right) const
{ // test for reference equality {
// test for reference equality
return (_Ptr == &_Right); return (_Ptr == &_Right);
} }
bool operator!=(const_reference _Right) const bool operator!=(const_reference _Right) const
{ // test for reference equality {
// test for reference equality
return (_Ptr != &_Right); return (_Ptr != &_Right);
} }
pointer _Mynode() pointer _Mynode()
{ // return node pointer {
// return node pointer
return (_Ptr); return (_Ptr);
} }

4
src/framework/Utilities/LinkedReference/RefManager.h
View file

@ -33,9 +33,9 @@ class RefManager : public LinkedListHead
RefManager() {} RefManager() {}
virtual ~RefManager() { clearReferences(); } 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> 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()); } Reference<TO, FROM> const* getLast() const { return ((Reference<TO, FROM> const*) LinkedListHead::getLast()); }
iterator begin() { return iterator(getFirst()); } iterator begin() { return iterator(getFirst()); }

8
src/framework/Utilities/LinkedReference/Reference.h
View file

@ -90,14 +90,14 @@ class Reference : public LinkedListElement
return iRefTo != NULL; 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> 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> 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> 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()); } Reference<TO,FROM> const* nocheck_prev() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_prev()); }
TO* operator->() const { return iRefTo; } TO* operator->() const { return iRefTo; }

38
src/framework/Utilities/UnorderedMapSet.h
View file

@ -73,7 +73,7 @@ template<class K>
class hash class hash
{ {
public: public:
size_t operator() (K const&); size_t operator()(K const&);
}; };
HASH_NAMESPACE_END HASH_NAMESPACE_END
@ -100,27 +100,27 @@ using std::hash_set;
HASH_NAMESPACE_START HASH_NAMESPACE_START
template<> template<>
class hash<unsigned long long> class hash<unsigned long long>
{ {
public: public:
size_t operator()(const unsigned long long &__x) const { return (size_t)__x; } size_t operator()(const unsigned long long& __x) const { return (size_t)__x; }
}; };
template<typename T> template<typename T>
class hash<T *> class hash<T*>
{ {
public: public:
size_t operator()(T * const &__x) const { return (size_t)__x; } 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 HASH_NAMESPACE_END