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

[9775] Cleanups in framework library.

Browse source 
* Removed last bits of threading in grid code.
* Removed some weird and unneeded declarations.
* General code style fixes.
* (Perhaps some things I forgot.)

Thanks to Lynx3d for the usual GCC-stabbing...
This commit is contained in:
XTZGZoReX 2010-04-22 11:49:36 +02:00
parent 4d89b41f60
commit 7532061a79
25 changed files with 774 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -42,13 +42,13 @@ template
<
class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES,
class ThreadModel = MaNGOS::SingleThreaded<ACTIVE_OBJECT>
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;
public:
/** destructor to clean up its resources. This includes unloading the
@ -58,74 +58,71 @@ class MANGOS_DLL_DECL Grid
/** an object of interested enters the grid
*/
template<class SPECIFIC_OBJECT> bool AddWorldObject(SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
bool AddWorldObject(SPECIFIC_OBJECT *obj)
{
return i_objects.template insert<SPECIFIC_OBJECT>(obj);
}
/** an object of interested exits the grid
*/
template<class SPECIFIC_OBJECT> bool RemoveWorldObject(SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
bool RemoveWorldObject(SPECIFIC_OBJECT *obj)
{
return i_objects.template remove<SPECIFIC_OBJECT>(obj);
}
/** Refreshes/update the grid. This required for remote grids.
*/
void RefreshGrid(void) { /* TBI */}
/** Locks a grid. Any object enters must wait until the grid is unlock.
*/
void LockGrid(void) { /* TBI */ }
/** Unlocks the grid.
*/
void UnlockGrid(void) { /* TBI */ }
/** Grid visitor for grid objects
*/
template<class T> void Visit(TypeContainerVisitor<T, TypeMapContainer<GRID_OBJECT_TYPES> > &visitor)
template<class T>
void Visit(TypeContainerVisitor<T, TypeMapContainer<GRID_OBJECT_TYPES> > &visitor)
{
visitor.Visit(i_container);
}
/** Grid visitor for world objects
*/
template<class T> void Visit(TypeContainerVisitor<T, TypeMapContainer<WORLD_OBJECT_TYPES> > &visitor)
template<class T>
void Visit(TypeContainerVisitor<T, TypeMapContainer<WORLD_OBJECT_TYPES> > &visitor)
{
visitor.Visit(i_objects);
}
/** Returns the number of object within the grid.
*/
unsigned int ActiveObjectsInGrid(void) const { return m_activeGridObjects.size()+i_objects.template Count<ACTIVE_OBJECT>(); }
uint32 ActiveObjectsInGrid() const
{
return m_activeGridObjects.size() + i_objects.template Count<ACTIVE_OBJECT>();
}
/** Inserts a container type object into the grid.
*/
template<class SPECIFIC_OBJECT> bool AddGridObject(SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
bool AddGridObject(SPECIFIC_OBJECT *obj)
{
if (obj->isActiveObject())
m_activeGridObjects.insert(obj);
return i_container.template insert<SPECIFIC_OBJECT>(obj);
}
/** Removes a containter type object from the grid
*/
template<class SPECIFIC_OBJECT> bool RemoveGridObject(SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
bool RemoveGridObject(SPECIFIC_OBJECT *obj)
{
if (obj->isActiveObject())
m_activeGridObjects.erase(obj);
return i_container.template remove<SPECIFIC_OBJECT>(obj);
}
private:
typedef typename ThreadModel::Lock Guard;
typedef typename ThreadModel::VolatileType VolatileType;
TypeMapContainer<GRID_OBJECT_TYPES> i_container;
TypeMapContainer<WORLD_OBJECT_TYPES> i_objects;
typedef std::set<void*> ActiveGridObjects;
ActiveGridObjects m_activeGridObjects;
};
#endif

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

@ -49,9 +49,7 @@ class MANGOS_DLL_DECL GridLoader
template<class LOADER>
void Load(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, LOADER &loader)
{
grid.LockGrid();
loader.Load(grid);
grid.UnlockGrid();
}
/** Stop the grid
@ -59,18 +57,16 @@ class MANGOS_DLL_DECL GridLoader
template<class STOPER>
void Stop(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, STOPER &stoper)
{
grid.LockGrid();
stoper.Stop(grid);
grid.UnlockGrid();
}
/** Unloads the grid
*/
template<class UNLOADER>
void Unload(Grid<ACTIVE_OBJECT,WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> &grid, UNLOADER &unloader)
{
grid.LockGrid();
unloader.Unload(grid);
grid.UnlockGrid();
}
};
#endif

15
src/framework/GameSystem/GridRefManager.h
View file

@ -21,17 +21,24 @@
#include "Utilities/LinkedReference/RefManager.h"
template<class OBJECT>
class GridReference;
template<class OBJECT> class GridReference;
template<class OBJECT>
class GridRefManager : public RefManager<GridRefManager<OBJECT>, OBJECT>
{
public:
typedef LinkedListHead::Iterator< GridReference<OBJECT> > iterator;
GridReference<OBJECT>* getFirst() { return (GridReference<OBJECT>*)RefManager<GridRefManager<OBJECT>, OBJECT>::getFirst(); }
GridReference<OBJECT>* getLast() { return (GridReference<OBJECT>*)RefManager<GridRefManager<OBJECT>, OBJECT>::getLast(); }
GridReference<OBJECT>* getFirst()
{
return (GridReference<OBJECT>*)RefManager<GridRefManager<OBJECT>, OBJECT>::getFirst();
}
GridReference<OBJECT>* getLast()
{
return (GridReference<OBJECT>*)RefManager<GridRefManager<OBJECT>, OBJECT>::getLast();
}
iterator begin() { return iterator(getFirst()); }
iterator end() { return iterator(NULL); }

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

@ -21,32 +21,49 @@
#include "Utilities/LinkedReference/Reference.h"
template<class OBJECT>
class GridRefManager;
template<class OBJECT> class GridRefManager;
template<class OBJECT>
class MANGOS_DLL_SPEC GridReference : public Reference<GridRefManager<OBJECT>, OBJECT>
{
protected:
void targetObjectBuildLink()
{
// called from link()
this->getTarget()->insertFirst(this);
this->getTarget()->incSize();
}
void targetObjectDestroyLink()
{
// called from unlink()
if(this->isValid()) this->getTarget()->decSize();
if (this->isValid())
this->getTarget()->decSize();
}
void sourceObjectDestroyLink()
{
// called from invalidate()
this->getTarget()->decSize();
}
public:
GridReference() : Reference<GridRefManager<OBJECT>, OBJECT>() {}
~GridReference() { this->unlink(); }
GridReference *next() { return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next(); }
GridReference()
: Reference<GridRefManager<OBJECT>, OBJECT>()
{
}
~GridReference()
{
this->unlink();
}
GridReference *next()
{
return (GridReference*)Reference<GridRefManager<OBJECT>, OBJECT>::next();
}
};
#endif

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

@ -29,12 +29,26 @@
class GridInfo
{
public:
GridInfo()
: i_timer(0), i_unloadActiveLockCount(0), i_unloadExplicitLock(false), i_unloadReferenceLock(false) {}
: i_timer(0), i_unloadActiveLockCount(0), i_unloadExplicitLock(false),
i_unloadReferenceLock(false)
{
}
GridInfo(time_t expiry, bool unload = true )
: i_timer(expiry), i_unloadActiveLockCount(0), i_unloadExplicitLock(!unload), i_unloadReferenceLock(false) {}
: i_timer(expiry), i_unloadActiveLockCount(0), i_unloadExplicitLock(!unload),
i_unloadReferenceLock(false)
{
}
const TimeTracker& getTimeTracker() const { return i_timer; }
bool getUnloadLock() const { return i_unloadActiveLockCount || i_unloadExplicitLock || i_unloadReferenceLock; }
bool getUnloadLock() const
{
return i_unloadActiveLockCount || i_unloadExplicitLock || i_unloadReferenceLock;
}
void setUnloadExplicitLock( bool on ) { i_unloadExplicitLock = on; }
void setUnloadReferenceLock( bool on ) { i_unloadReferenceLock = on; }
void incUnloadActiveLock() { ++i_unloadActiveLockCount; }
@ -45,6 +59,7 @@ public:
void UpdateTimeTracker(time_t diff) { i_timer.Update(diff); }
private:
TimeTracker i_timer;
uint16 i_unloadActiveLockCount : 16; // lock from active object spawn points (prevent clone loading)
bool i_unloadExplicitLock : 1; // explicit manual lock or config setting
@ -62,48 +77,49 @@ typedef enum
template
<
unsigned int N,
uint32 N,
class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES,
class ThreadModel = MaNGOS::SingleThreaded<ACTIVE_OBJECT>
class GRID_OBJECT_TYPES
>
class MANGOS_DLL_DECL NGrid
{
public:
typedef Grid<ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES, ThreadModel> GridType;
NGrid(uint32 id, int32 x, int32 y, time_t expiry, bool unload = true)
typedef Grid<ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> GridType;
NGrid(uint32 id, uint32 x, uint32 y, time_t expiry, bool unload = true)
: i_gridId(id), i_x(x), i_y(y), i_cellstate(GRID_STATE_INVALID), i_GridObjectDataLoaded(false)
{
i_GridInfo = GridInfo(expiry, unload);
}
const GridType& operator()(unsigned short x, unsigned short y) const
const GridType& operator()(uint32 x, uint32 y) const
{
ASSERT(x < N);
ASSERT(y < N);
return i_cells[x][y];
}
GridType& operator()(unsigned short x, unsigned short y)
GridType& operator()(uint32 x, uint32 y)
{
ASSERT(x < N);
ASSERT(y < N);
return i_cells[x][y];
}
const uint32& GetGridId(void) const { return i_gridId; }
const uint32& GetGridId() const { return i_gridId; }
void SetGridId(const uint32 id) const { i_gridId = id; }
grid_state_t GetGridState(void) const { return i_cellstate; }
grid_state_t GetGridState() const { return i_cellstate; }
void SetGridState(grid_state_t s) { i_cellstate = s; }
int32 getX() const { return i_x; }
int32 getY() const { return i_y; }
uint32 getX() const { return i_x; }
uint32 getY() const { return i_y; }
void link(GridRefManager<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES, ThreadModel> >* pTo)
void link(GridRefManager<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> >* pTo)
{
i_Reference.link(pTo, this);
}
bool isGridObjectDataLoaded() const { return i_GridObjectDataLoaded; }
void setGridObjectDataLoaded(bool pLoaded) { i_GridObjectDataLoaded = pLoaded; }
@ -117,43 +133,50 @@ class MANGOS_DLL_DECL NGrid
void ResetTimeTracker(time_t interval) { i_GridInfo.ResetTimeTracker(interval); }
void UpdateTimeTracker(time_t diff) { i_GridInfo.UpdateTimeTracker(diff); }
template<class SPECIFIC_OBJECT> void AddWorldObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
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)
template<class SPECIFIC_OBJECT>
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)
template<class T, class TT>
void Visit(TypeContainerVisitor<T, TypeMapContainer<TT> > &visitor)
{
for(unsigned int x=0; x < N; ++x)
for(unsigned int y=0; y < N; ++y)
for (uint32 x = 0; x < N; ++x)
for (uint32 y = 0; y < N; ++y)
i_cells[x][y].Visit(visitor);
}
template<class T, class TT> void Visit(const uint32 &x, const uint32 &y, TypeContainerVisitor<T, TypeMapContainer<TT> > &visitor)
template<class T, class TT>
void Visit(const uint32 &x, const uint32 &y, TypeContainerVisitor<T, TypeMapContainer<TT> > &visitor)
{
getGridType(x, y).Visit(visitor);
}
unsigned int ActiveObjectsInGrid(void) const
uint32 ActiveObjectsInGrid() const
{
unsigned int count=0;
for(unsigned int x=0; x < N; ++x)
for(unsigned int y=0; y < N; ++y)
uint32 count = 0;
for (uint32 x = 0; x < N; ++x)
for (uint32 y = 0; y < N; ++y)
count += i_cells[x][y].ActiveObjectsInGrid();
return count;
}
template<class SPECIFIC_OBJECT> bool AddGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
template<class SPECIFIC_OBJECT>
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)
template<class SPECIFIC_OBJECT>
bool RemoveGridObject(const uint32 x, const uint32 y, SPECIFIC_OBJECT *obj)
{
return getGridType(x, y).RemoveGridObject(obj);
}
@ -169,11 +192,12 @@ class MANGOS_DLL_DECL NGrid
uint32 i_gridId;
GridInfo i_GridInfo;
GridReference<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES, ThreadModel> > i_Reference;
int32 i_x;
int32 i_y;
GridReference<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> > i_Reference;
uint32 i_x;
uint32 i_y;
grid_state_t i_cellstate;
GridType i_cells[N][N];
bool i_GridObjectDataLoaded;
};
#endif

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

@ -31,14 +31,19 @@
#include "Utilities/UnorderedMap.h"
#include "GameSystem/GridRefManager.h"
template<class OBJECT, class KEY_TYPE> struct ContainerUnorderedMap
template<class OBJECT, class KEY_TYPE>
struct ContainerUnorderedMap
{
UNORDERED_MAP<KEY_TYPE, OBJECT*> _element;
};
template<class KEY_TYPE> struct ContainerUnorderedMap<TypeNull, KEY_TYPE>
template<class KEY_TYPE>
struct ContainerUnorderedMap<TypeNull, KEY_TYPE>
{
};
template<class H, class T, class KEY_TYPE> struct ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >
template<class H, class T, class KEY_TYPE>
struct ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >
{
ContainerUnorderedMap<H, KEY_TYPE> _elements;
ContainerUnorderedMap<T, KEY_TYPE> _TailElements;
@ -48,24 +53,33 @@ template<class OBJECT_TYPES, class KEY_TYPE = OBJECT_HANDLE>
class TypeUnorderedMapContainer
{
public:
template<class SPECIFIC_TYPE> bool insert(KEY_TYPE handle, SPECIFIC_TYPE* obj)
template<class SPECIFIC_TYPE>
bool insert(KEY_TYPE handle, SPECIFIC_TYPE* obj)
{
return TypeUnorderedMapContainer::insert(i_elements, handle, obj);
}
template<class SPECIFIC_TYPE> bool erase(KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
bool erase(KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
{
return TypeUnorderedMapContainer::erase(i_elements, handle, (SPECIFIC_TYPE*)NULL);
}
template<class SPECIFIC_TYPE> SPECIFIC_TYPE* find(KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
SPECIFIC_TYPE* find(KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
{
return TypeUnorderedMapContainer::find(i_elements, hdl, (SPECIFIC_TYPE*)NULL);
}
private:
ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> i_elements;
// Helpers
// Insert helpers
template<class SPECIFIC_TYPE> static bool insert(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
template<class SPECIFIC_TYPE>
static bool insert(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
{
typename UNORDERED_MAP<KEY_TYPE, SPECIFIC_TYPE*>::iterator i = elements._element.find(handle);
if (i == elements._element.end())
@ -75,25 +89,33 @@ class TypeUnorderedMapContainer
}
else
{
assert (i->second == obj && "Object with certain key already in but objects are different!");
ASSERT(i->second == obj && "Object with certain key already in but objects are different!");
return false;
}
}
template<class SPECIFIC_TYPE> static bool insert(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
static bool insert(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
{
return false;
}
template<class SPECIFIC_TYPE, class T> static bool insert(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE, class T>
static bool insert(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
{
return false;
}
template<class SPECIFIC_TYPE, class H, class T> static bool insert(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
template<class SPECIFIC_TYPE, class H, class T>
static bool insert(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
{
bool ret = TypeUnorderedMapContainer::insert(elements._elements, handle, obj);
return ret ? ret : TypeUnorderedMapContainer::insert(elements._TailElements, handle, obj);
}
// Find helpers
template<class SPECIFIC_TYPE> static SPECIFIC_TYPE* find(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
static SPECIFIC_TYPE* find(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
{
typename UNORDERED_MAP<KEY_TYPE, SPECIFIC_TYPE*>::iterator i = elements._element.find(hdl);
if (i == elements._element.end())
@ -101,35 +123,49 @@ class TypeUnorderedMapContainer
else
return i->second;
}
template<class SPECIFIC_TYPE> static SPECIFIC_TYPE* find(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
static SPECIFIC_TYPE* find(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
{
return NULL;
}
template<class SPECIFIC_TYPE, class T> static SPECIFIC_TYPE* find(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE, class T>
static SPECIFIC_TYPE* find(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
{
return NULL;
}
template<class SPECIFIC_TYPE, class H, class T> static SPECIFIC_TYPE* find(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE, class H, class T>
static SPECIFIC_TYPE* find(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
{
SPECIFIC_TYPE* ret = TypeUnorderedMapContainer::find(elements._elements, hdl, (SPECIFIC_TYPE*)NULL);
return ret ? ret : TypeUnorderedMapContainer::find(elements._TailElements, hdl, (SPECIFIC_TYPE*)NULL);
}
// Erase helpers
template<class SPECIFIC_TYPE> static bool erase(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
static bool erase(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
{
elements._element.erase(handle);
return true;
}
template<class SPECIFIC_TYPE> static bool erase(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE>
static bool erase(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
{
return false;
}
template<class SPECIFIC_TYPE, class T> static bool erase(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE, class T>
static bool erase(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
{
return false;
}
template<class SPECIFIC_TYPE, class H, class T> static bool erase(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
template<class SPECIFIC_TYPE, class H, class T>
static bool erase(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
{
bool ret = TypeUnorderedMapContainer::erase(elements._elements, handle, (SPECIFIC_TYPE*)NULL);
return ret ? ret : TypeUnorderedMapContainer::erase(elements._TailElements, handle, (SPECIFIC_TYPE*)NULL);
@ -141,21 +177,24 @@ class TypeUnorderedMapContainer
* By itself its meaningless but collaborate along with TypeContainers,
* it become the most powerfully container in the whole system.
*/
template<class OBJECT> struct ContainerMapList
template<class OBJECT>
struct ContainerMapList
{
GridRefManager<OBJECT> _element;
};
template<> struct ContainerMapList<TypeNull> /* nothing is in type null */
template<>
struct ContainerMapList<TypeNull> /* nothing is in type null */
{
};
template<class H, class T> struct ContainerMapList<TypeList<H, T> >
template<class H, class T>
struct ContainerMapList<TypeList<H, T> >
{
ContainerMapList<H> _elements;
ContainerMapList<T> _TailElements;
};
#include "TypeContainerFunctions.h"
/*
@ -169,26 +208,32 @@ template<class OBJECT_TYPES>
class MANGOS_DLL_DECL TypeMapContainer
{
public:
template<class SPECIFIC_TYPE> size_t Count() const { return MaNGOS::Count(i_elements, (SPECIFIC_TYPE*)NULL); }
template<class SPECIFIC_TYPE>
size_t Count() const { return MaNGOS::Count(i_elements, (SPECIFIC_TYPE*)NULL); }
/// inserts a specific object into the container
template<class SPECIFIC_TYPE> bool insert(SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE>
bool insert(SPECIFIC_TYPE *obj)
{
SPECIFIC_TYPE* t = MaNGOS::Insert(i_elements, obj);
return (t != NULL);
}
/// Removes the object from the container, and returns the removed object
template<class SPECIFIC_TYPE> bool remove(SPECIFIC_TYPE* obj)
template<class SPECIFIC_TYPE>
bool remove(SPECIFIC_TYPE* obj)
{
SPECIFIC_TYPE* t = MaNGOS::Remove(i_elements, obj);
return (t != NULL);
}
ContainerMapList<OBJECT_TYPES> & GetElements(void) { return i_elements; }
const ContainerMapList<OBJECT_TYPES> & GetElements(void) const { return i_elements;}
ContainerMapList<OBJECT_TYPES> & GetElements() { return i_elements; }
const ContainerMapList<OBJECT_TYPES> & GetElements() const { return i_elements;}
private:
ContainerMapList<OBJECT_TYPES> i_elements;
};
#endif

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

@ -33,81 +33,94 @@ namespace MaNGOS
{
/* ContainerMapList Helpers */
// count functions
template<class SPECIFIC_TYPE> size_t Count(const ContainerMapList<SPECIFIC_TYPE> &elements, SPECIFIC_TYPE* /*fake*/)
template<class SPECIFIC_TYPE>
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*/)
template<class SPECIFIC_TYPE>
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*/)
template<class SPECIFIC_TYPE, class T>
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)
template<class SPECIFIC_TYPE, class T>
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)
template<class SPECIFIC_TYPE, class H, class T>
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)
template<class SPECIFIC_TYPE>
SPECIFIC_TYPE* Insert(ContainerMapList<SPECIFIC_TYPE> &elements, SPECIFIC_TYPE *obj)
{
//elements._element[hdl] = obj;
obj->GetGridRef().link(&elements._element, obj);
return obj;
};
}
template<class SPECIFIC_TYPE> SPECIFIC_TYPE* Insert(ContainerMapList<TypeNull> &/*elements*/, SPECIFIC_TYPE * /*obj*/)
template<class SPECIFIC_TYPE>
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*/)
template<class SPECIFIC_TYPE, class T>
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)
template<class SPECIFIC_TYPE, class H, class T>
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));
}
// non-const remove method
template<class SPECIFIC_TYPE> SPECIFIC_TYPE* Remove(ContainerMapList<SPECIFIC_TYPE> & /*elements*/, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE>
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*/)
template<class SPECIFIC_TYPE>
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*/)
template<class SPECIFIC_TYPE, class T>
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)
template<class SPECIFIC_TYPE, class T, class H>
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) );
}
}
#endif

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

@ -32,30 +32,35 @@
template<class T, class Y> class TypeContainerVisitor;
// visitor helper
template<class VISITOR, class TYPE_CONTAINER> void VisitorHelper(VISITOR &v, TYPE_CONTAINER &c)
template<class VISITOR, class TYPE_CONTAINER>
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*/)
template<class VISITOR>
void VisitorHelper(VISITOR &/*v*/, ContainerMapList<TypeNull> &/*c*/)
{
}
template<class VISITOR, class T> void VisitorHelper(VISITOR &v, ContainerMapList<T> &c)
template<class VISITOR, class T>
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)
template<class VISITOR, class H, class T>
void VisitorHelper(VISITOR &v, ContainerMapList<TypeList<H, T> > &c)
{
VisitorHelper(v, c._elements);
VisitorHelper(v, c._TailElements);
}
// for TypeMapContainer
template<class VISITOR, class OBJECT_TYPES> void VisitorHelper(VISITOR &v, TypeMapContainer<OBJECT_TYPES> &c)
template<class VISITOR, class OBJECT_TYPES>
void VisitorHelper(VISITOR &v, TypeMapContainer<OBJECT_TYPES> &c)
{
VisitorHelper(v, c.GetElements());
}
@ -64,7 +69,11 @@ template<class VISITOR, class TYPE_CONTAINER>
class MANGOS_DLL_DECL TypeContainerVisitor
{
public:
TypeContainerVisitor(VISITOR &v) : i_visitor(v) {}
TypeContainerVisitor(VISITOR &v)
: i_visitor(v)
{
}
void Visit(TYPE_CONTAINER &c)
{
@ -77,6 +86,8 @@ class MANGOS_DLL_DECL TypeContainerVisitor
}
private:
VISITOR &i_visitor;
};
#endif

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

@ -31,8 +31,16 @@ namespace MaNGOS
class MANGOS_DLL_DECL OperatorNew
{
public:
static T* Create(void) { return (new T); }
static void Destroy(T *obj) { delete obj; }
static T* Create()
{
return (new T);
}
static void Destroy(T *obj)
{
delete obj;
}
};
/**
@ -55,14 +63,19 @@ namespace MaNGOS
int Test::* pMember_;
int (Test::*pMemberFn_)(int);
};
public:
static T* Create(void)
static T* Create()
{
static MaxAlign si_localStatic;
return new(&si_localStatic) T;
}
static void Destroy(T *obj) { obj->~T(); }
static void Destroy(T *obj)
{
obj->~T();
}
};
/**
@ -72,17 +85,21 @@ namespace MaNGOS
class MANGOS_DLL_DECL CreateUsingMalloc
{
public:
static T* Create()
{
void* p = ::malloc(sizeof(T));
if (!p) return 0;
void* p = malloc(sizeof(T));
if (!p)
return NULL;
return new(p) T;
}
static void Destroy(T* p)
{
p->~T();
::free(p);
free(p);
}
};
@ -104,4 +121,5 @@ namespace MaNGOS
}
};
}
#endif

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

@ -25,14 +25,20 @@
void* operator new(size_t sz)
{
void *res = scalable_malloc(sz);
if (NULL == res) throw std::bad_alloc();
if (res == NULL)
throw std::bad_alloc();
return res;
}
void* operator new[](size_t sz)
{
void *res = scalable_malloc(sz);
if (NULL == res) throw std::bad_alloc();
if (res == NULL)
throw std::bad_alloc();
return res;
}

7
src/framework/Policies/ObjectLifeTime.h
View file

@ -32,19 +32,20 @@ namespace MaNGOS
class MANGOS_DLL_DECL ObjectLifeTime
{
public:
static void ScheduleCall(void (*destroyer)())
{
at_exit(destroyer);
}
DECLSPEC_NORETURN static void OnDeadReference(void) ATTR_NORETURN;
DECLSPEC_NORETURN static void OnDeadReference() ATTR_NORETURN;
};
template <class T>
void ObjectLifeTime<T>::OnDeadReference(void) // We don't handle Dead Reference for now
void ObjectLifeTime<T>::OnDeadReference() // We don't handle Dead Reference for now
{
throw std::runtime_error("Dead Reference");
}
}
#endif

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

@ -39,10 +39,14 @@ namespace MaNGOS
class MANGOS_DLL_DECL Singleton
{
public:
static T& Instance();
protected:
Singleton() {};
Singleton()
{
}
private:
@ -59,4 +63,5 @@ namespace MaNGOS
static bool si_destroyed;
};
}
#endif

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

@ -31,13 +31,13 @@ class ThreadingModel,
class CreatePolicy,
class LifeTimePolicy
>
T&
MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy >::Instance()
T& MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::Instance()
{
if (!si_instance)
{
// double-checked Locking pattern
Guard();
if (!si_instance)
{
if (si_destroyed)
@ -45,6 +45,7 @@ MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy >::Instance()
si_destroyed = false;
LifeTimePolicy::OnDeadReference();
}
si_instance = CreatePolicy::Create();
LifeTimePolicy::ScheduleCall(&DestroySingleton);
}
@ -60,8 +61,7 @@ class ThreadingModel,
class CreatePolicy,
class LifeTimePolicy
>
void
MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingleton()
void MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingleton()
{
CreatePolicy::Destroy(si_instance);
si_instance = NULL;
@ -87,4 +87,5 @@ MaNGOS::Singleton<T, ThreadingModel, CreatePolicy, LifeTimePolicy>::DestroySingl
template class MANGOS_DLL_DECL MaNGOS::Singleton<TYPE, THREADINGMODEL, CREATIONPOLICY, OBJECTLIFETIME >; \
template<> TYPE* MaNGOS::Singleton<TYPE, THREADINGMODEL, CREATIONPOLICY, OBJECTLIFETIME >::si_instance = 0; \
template<> bool MaNGOS::Singleton<TYPE, THREADINGMODEL, CREATIONPOLICY, OBJECTLIFETIME >::si_destroyed = false
#endif

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

@ -28,12 +28,13 @@
namespace MaNGOS
{
inline void Guard(void *) {}
template<typename MUTEX> class MANGOS_DLL_DECL GeneralLock
template<typename MUTEX>
class MANGOS_DLL_DECL GeneralLock
{
public:
GeneralLock(MUTEX &m) : i_mutex(m)
GeneralLock(MUTEX &m)
: i_mutex(m)
{
i_mutex.acquire();
}
@ -42,7 +43,9 @@ namespace MaNGOS
{
i_mutex.release();
}
private:
GeneralLock(const GeneralLock &);
GeneralLock& operator=(const GeneralLock &);
MUTEX &i_mutex;
@ -55,39 +58,47 @@ namespace MaNGOS
struct Lock // empty object
{
Lock() {}
Lock(const T &) {}
Lock()
{
}
Lock(const T&)
{
}
Lock(const SingleThreaded<T>&) // for single threaded we ignore this
{
}
};
typedef T VolatileType;
};
// object level lockable
template<class T, class MUTEX>
class MANGOS_DLL_DECL ObjectLevelLockable
{
public:
ObjectLevelLockable() : i_mtx() {}
ObjectLevelLockable()
: i_mtx()
{
}
friend class Lock;
class Lock
{
public:
Lock(ObjectLevelLockable<T, MUTEX> &host) : i_lock(host.i_mtx)
Lock(ObjectLevelLockable<T, MUTEX> &host)
: i_lock(host.i_mtx)
{
}
private:
GeneralLock<MUTEX> i_lock;
};
typedef volatile T VolatileType;
private:
// prevent the compiler creating a copy construct
ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
@ -99,22 +110,40 @@ namespace MaNGOS
class MANGOS_DLL_DECL ClassLevelLockable
{
public:
class Lock;
friend class Lock;
typedef volatile T VolatileType;
ClassLevelLockable() {}
ClassLevelLockable()
{
}
friend class Lock;
class Lock
{
public:
Lock(T& /*host*/) { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); }
Lock(ClassLevelLockable<T, MUTEX> &) { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); }
Lock() { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); }
~Lock() { ClassLevelLockable<T, MUTEX>::si_mtx.release(); }
Lock(T& /*host*/)
{
ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
}
Lock(ClassLevelLockable<T, MUTEX> &)
{
ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
}
Lock()
{
ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
}
~Lock()
{
ClassLevelLockable<T, MUTEX>::si_mtx.release();
}
};
private:
static MUTEX si_mtx;
};
@ -124,4 +153,5 @@ template<class T, class MUTEX> MUTEX MaNGOS::ClassLevelLockable<T, MUTEX>::si_mt
#define INSTANTIATE_CLASS_MUTEX(CTYPE, MUTEX) \
template class MANGOS_DLL_DECL MaNGOS::ClassLevelLockable<CTYPE, MUTEX>
#endif

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

@ -38,7 +38,8 @@ namespace ByteConverter
template<> inline void convert<0>(char *) {}
template<> inline void convert<1>(char *) {} // ignore central byte
template<typename T> inline void apply(T *val)
template<typename T>
inline void apply(T *val)
{
convert<sizeof(T)>((char *)(val));
}

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

@ -27,6 +27,7 @@ namespace MaNGOS
class _Callback
{
protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
Class *m_object;
Method m_method;
@ -35,17 +36,27 @@ namespace MaNGOS
ParamType3 m_param3;
ParamType4 m_param4;
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3, m_param4); }
public:
_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_object(object), m_method(method),
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
{
}
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
: m_object(cb.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_object(cb.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)
{
}
};
template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
class _Callback<Class, ParamType1, ParamType2, ParamType3>
{
protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
Class *m_object;
Method m_method;
@ -53,59 +64,93 @@ namespace MaNGOS
ParamType2 m_param2;
ParamType3 m_param3;
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
public:
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_object(object), m_method(method), m_param1(param1), m_param2(param2) {}
: m_object(object), m_method(method),
m_param1(param1), m_param2(param2)
{
}
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3> const& cb)
: m_object(cb.object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3) {}
: m_object(cb.object), m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
{
}
};
template<class Class, typename ParamType1, typename ParamType2>
class _Callback<Class, ParamType1, ParamType2>
{
protected:
typedef void (Class::*Method)(ParamType1, ParamType2);
Class *m_object;
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
void _Execute() { (m_object->*m_method)(m_param1, m_param2); }
public:
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2)
: m_object(object), m_method(method), m_param1(param1), m_param2(param2) {}
: m_object(object), m_method(method),
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_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2)
{
}
};
template<class Class, typename ParamType1>
class _Callback<Class, ParamType1>
{
protected:
typedef void (Class::*Method)(ParamType1);
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)
: m_object(object), m_method(method), m_param1(param1) {}
: m_object(object), m_method(method),
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_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1)
{
}
};
template<class Class>
class _Callback<Class>
{
protected:
typedef void (Class::*Method)();
Class *m_object;
Method m_method;
void _Execute() { (m_object->*m_method)(); }
public:
_Callback(Class *object, Method method)
: m_object(object), m_method(method) {}
: m_object(object), m_method(method)
{
}
_Callback(_Callback<Class> const& cb)
: m_object(cb.m_object), m_method(cb.m_method) {}
: m_object(cb.m_object), m_method(cb.m_method)
{
}
};
/// ---- Statics ----
@ -114,6 +159,7 @@ namespace MaNGOS
class _SCallback
{
protected:
typedef void (*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
Method m_method;
ParamType1 m_param1;
@ -121,73 +167,116 @@ namespace MaNGOS
ParamType3 m_param3;
ParamType4 m_param4;
void _Execute() { (*m_method)(m_param1, m_param2, m_param3, m_param4); }
public:
_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_method(method),
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_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
{
}
};
template<typename ParamType1, typename ParamType2, typename ParamType3>
class _SCallback<ParamType1, ParamType2, ParamType3>
{
protected:
typedef void (*Method)(ParamType1, ParamType2, ParamType3);
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
ParamType3 m_param3;
void _Execute() { (*m_method)(m_param1, m_param2, m_param3); }
public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_method(method), m_param1(param1), m_param2(param2), m_param3(param3) {}
: m_method(method),
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_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
{
}
};
template<typename ParamType1, typename ParamType2>
class _SCallback<ParamType1, ParamType2>
{
protected:
typedef void (*Method)(ParamType1, ParamType2);
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
void _Execute() { (*m_method)(m_param1, m_param2); }
public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2)
: m_method(method), m_param1(param1), m_param2(param2) {}
: m_method(method),
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_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2)
{
}
};
template<typename ParamType1>
class _SCallback<ParamType1>
{
protected:
typedef void (*Method)(ParamType1);
Method m_method;
ParamType1 m_param1;
void _Execute() { (*m_method)(m_param1); }
public:
_SCallback(Method method, ParamType1 param1)
: m_method(method), m_param1(param1) {}
: m_method(method),
m_param1(param1)
{
}
_SCallback(_SCallback<ParamType1> const& cb)
: m_method(cb.m_method), m_param1(cb.m_param1) {}
: m_method(cb.m_method),
m_param1(cb.m_param1)
{
}
};
template<>
class _SCallback<>
{
protected:
typedef void (*Method)();
Method m_method;
void _Execute() { (*m_method)(); }
public:
_SCallback(Method method)
: m_method(method) {}
: m_method(method)
{
}
_SCallback(_SCallback<> const& cb)
: m_method(cb.m_method) {}
: m_method(cb.m_method)
{
}
};
}
@ -198,6 +287,7 @@ namespace MaNGOS
class ICallback
{
public:
virtual void Execute() = 0;
virtual ~ICallback() {}
};
@ -206,62 +296,84 @@ namespace MaNGOS
class _ICallback : public CB, public ICallback
{
public:
_ICallback(CB const& cb) : CB(cb) {}
_ICallback(CB const& cb) : CB(cb)
{
}
void Execute() { CB::_Execute(); }
};
template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
class Callback :
public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4 > >
class Callback : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> >
{
private:
typedef _Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> C4;
public:
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))
{
}
};
template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
class Callback < Class, ParamType1, ParamType2, ParamType3 > :
public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3 > >
class Callback<Class, ParamType1, ParamType2, ParamType3> : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3> >
{
private:
typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3;
public:
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))
{
}
};
template<class Class, typename ParamType1, typename ParamType2>
class Callback < Class, ParamType1, ParamType2 > :
public _ICallback< _Callback < Class, ParamType1, ParamType2 > >
class Callback<Class, ParamType1, ParamType2> : public _ICallback<_Callback<Class, ParamType1, ParamType2> >
{
private:
typedef _Callback<Class, ParamType1, ParamType2> C2;
public:
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))
{
}
};
template<class Class, typename ParamType1>
class Callback < Class, ParamType1 > :
public _ICallback< _Callback < Class, ParamType1 > >
class Callback<Class, ParamType1> : public _ICallback<_Callback<Class, ParamType1> >
{
private:
typedef _Callback<Class, ParamType1> C1;
public:
Callback(Class *object, typename C1::Method method, ParamType1 param1)
: _ICallback< C1 >(C1(object, method, param1)) {}
: _ICallback<C1>(C1(object, method, param1))
{
}
};
template<class Class>
class Callback<Class> : public _ICallback<_Callback<Class> >
{
private:
typedef _Callback<Class> C0;
public:
Callback(Class *object, typename C0::Method method)
: _ICallback< C0 >(C0(object, method)) {}
: _ICallback<C0>(C0(object, method))
{
}
};
}
@ -274,6 +386,7 @@ namespace MaNGOS
class IQueryCallback
{
public:
virtual void Execute() = 0;
virtual ~IQueryCallback() {}
virtual void SetResult(QueryResult* result) = 0;
@ -284,98 +397,135 @@ namespace MaNGOS
class _IQueryCallback : public CB, public IQueryCallback
{
public:
_IQueryCallback(CB const& cb) : CB(cb) {}
_IQueryCallback(CB const& cb) : CB(cb)
{
}
void Execute() { CB::_Execute(); }
void SetResult(QueryResult* result) { CB::m_param1 = result; }
QueryResult* GetResult() { return CB::m_param1; }
};
template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
class QueryCallback :
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2, ParamType3 > >
class QueryCallback : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> >
{
private:
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
public:
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))
{
}
};
template<class Class, typename ParamType1, typename ParamType2>
class QueryCallback < Class, ParamType1, ParamType2 > :
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2 > >
class QueryCallback<Class, ParamType1, ParamType2> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2> >
{
private:
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2> QC2;
public:
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))
{
}
};
template<class Class, typename ParamType1>
class QueryCallback < Class, ParamType1 > :
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1 > >
class QueryCallback<Class, ParamType1> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1> >
{
private:
typedef _Callback<Class, QueryResult*, ParamType1> QC1;
public:
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))
{
}
};
template<class Class>
class QueryCallback<Class> : public _IQueryCallback<_Callback<Class, QueryResult*> >
{
private:
typedef _Callback<Class, QueryResult*> QC0;
public:
QueryCallback(Class *object, typename QC0::Method method, QueryResult* result)
: _IQueryCallback< QC0 >(QC0(object, method, result)) {}
: _IQueryCallback<QC0>(QC0(object, method, result))
{
}
};
/// ---- Statics ----
template<typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
class SQueryCallback :
public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2, ParamType3 > >
class SQueryCallback : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> >
{
private:
typedef _SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
public:
SQueryCallback(typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: _IQueryCallback< QC3 >(QC3(method, result, param1, param2, param3)) {}
: _IQueryCallback<QC3>(QC3(method, result, param1, param2, param3))
{
}
};
template<typename ParamType1, typename ParamType2>
class SQueryCallback < ParamType1, ParamType2 > :
public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2 > >
class SQueryCallback < ParamType1, ParamType2 > : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2> >
{
private:
typedef _SCallback<QueryResult*, ParamType1, ParamType2> QC2;
public:
SQueryCallback(typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
: _IQueryCallback< QC2 >(QC2(method, result, param1, param2)) {}
: _IQueryCallback<QC2>(QC2(method, result, param1, param2))
{
}
};
template<typename ParamType1>
class SQueryCallback < ParamType1 > :
public _IQueryCallback< _SCallback < QueryResult*, ParamType1 > >
class SQueryCallback<ParamType1> : public _IQueryCallback<_SCallback<QueryResult*, ParamType1> >
{
private:
typedef _SCallback<QueryResult*, ParamType1> QC1;
public:
SQueryCallback(typename QC1::Method method, QueryResult* result, ParamType1 param1)
: _IQueryCallback< QC1 >(QC1(method, result, param1)) {}
: _IQueryCallback<QC1>(QC1(method, result, param1))
{
}
};
template<>
class SQueryCallback<> : public _IQueryCallback<_SCallback<QueryResult*> >
{
private:
typedef _SCallback<QueryResult*> QC0;
public:
SQueryCallback(QC0::Method method, QueryResult* result)
: _IQueryCallback< QC0 >(QC0(method, result)) {}
: _IQueryCallback<QC0>(QC0(method, result))
{
}
};
}

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

@ -87,12 +87,14 @@ void EventProcessor::KillAllEvents(bool force)
void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime)
{
if (set_addtime) Event->m_addTime = m_time;
if (set_addtime)
Event->m_addTime = m_time;
Event->m_execTime = e_time;
m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event));
}
uint64 EventProcessor::CalculateTime(uint64 t_offset)
{
return(m_time + t_offset);
return m_time + t_offset;
}

11
src/framework/Utilities/EventProcessor.h
View file

@ -28,7 +28,12 @@
class BasicEvent
{
public:
BasicEvent() { to_Abort = false; }
BasicEvent()
: to_Abort(false)
{
}
virtual ~BasicEvent() // override destructor to perform some actions on event removal
{
};
@ -55,6 +60,7 @@ typedef std::multimap<uint64, BasicEvent*> EventList;
class EventProcessor
{
public:
EventProcessor();
~EventProcessor();
@ -62,9 +68,12 @@ class EventProcessor
void KillAllEvents(bool force);
void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
uint64 CalculateTime(uint64 t_offset);
protected:
uint64 m_time;
EventList m_events;
bool m_aborting;
};
#endif

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

@ -27,11 +27,14 @@ class LinkedListHead;
class LinkedListElement
{
private:
friend class LinkedListHead;
LinkedListElement* iNext;
LinkedListElement* iPrev;
public:
LinkedListElement() { iNext = NULL; iPrev = NULL; }
~LinkedListElement() { delink(); }
@ -53,7 +56,10 @@ class LinkedListElement
{
if (isInList())
{
iNext->iPrev = iPrev; iPrev->iNext = iNext; iNext = NULL; iPrev = NULL;
iNext->iPrev = iPrev;
iPrev->iNext = iNext;
iNext = NULL;
iPrev = NULL;
}
}
@ -79,10 +85,13 @@ class LinkedListElement
class LinkedListHead
{
private:
LinkedListElement iFirst;
LinkedListElement iLast;
uint32 iSize;
public:
LinkedListHead()
{
// create empty list
@ -116,11 +125,13 @@ class LinkedListHead
{
uint32 result = 0;
LinkedListElement const* e = getFirst();
while(e)
{
++result;
e = e->next();
}
return result;
}
else
@ -134,6 +145,7 @@ class LinkedListHead
class Iterator
{
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef _Ty value_type;
typedef ptrdiff_t difference_type;
@ -144,11 +156,13 @@ class LinkedListHead
typedef _Ty const& const_reference;
Iterator() : _Ptr(0)
Iterator()
: _Ptr(0)
{ // construct with null node pointer
}
Iterator(pointer _Pnode) : _Ptr(_Pnode)
Iterator(pointer _Pnode)
: _Ptr(_Pnode)
{ // construct with node pointer _Pnode
}
@ -229,13 +243,13 @@ class LinkedListHead
return (_Ptr != &_Right);
}
pointer _Mynode()
{ // return node pointer
return (_Ptr);
}
protected:
pointer _Ptr; // pointer to node
};
@ -243,4 +257,5 @@ class LinkedListHead
};
//============================================
#endif

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

@ -18,14 +18,17 @@
#ifndef _REFMANAGER_H
#define _REFMANAGER_H
//=====================================================
#include "Utilities/LinkedList.h"
#include "Utilities/LinkedReference/Reference.h"
template <class TO, class FROM> class RefManager : public LinkedListHead
template <class TO, class FROM>
class RefManager : public LinkedListHead
{
public:
typedef LinkedListHead::Iterator<Reference<TO, FROM> > iterator;
RefManager() {}
virtual ~RefManager() { clearReferences(); }
@ -52,4 +55,5 @@ template <class TO, class FROM> class RefManager : public LinkedListHead
};
//=====================================================
#endif

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

@ -23,12 +23,16 @@
//=====================================================
template <class TO, class FROM> class Reference : public LinkedListElement
template<class TO, class FROM>
class Reference : public LinkedListElement
{
private:
TO* iRefTo;
FROM* iRefFrom;
protected:
// Tell our refTo (target) object that we have a link
virtual void targetObjectBuildLink() = 0;
@ -37,16 +41,23 @@ template <class TO, class FROM> class Reference : public LinkedListElement
// Tell our refFrom (source) object, that the link is cut (Target destroyed)
virtual void sourceObjectDestroyLink() = 0;
public:
Reference() { iRefTo = NULL; iRefFrom = NULL; }
Reference()
: iRefTo(NULL), iRefFrom(NULL)
{
}
virtual ~Reference() {}
// Create new link
void link(TO* toObj, FROM* fromObj)
{
assert(fromObj); // fromObj MUST not be NULL
ASSERT(fromObj); // fromObj MUST not be NULL
if (isValid())
unlink();
if (toObj != NULL)
{
iRefTo = toObj;
@ -57,13 +68,21 @@ template <class TO, class FROM> class Reference : public LinkedListElement
// We don't need the reference anymore. Call comes from the refFrom object
// Tell our refTo object, that the link is cut
void unlink() { targetObjectDestroyLink(); delink(); iRefTo = NULL; iRefFrom = NULL; }
void unlink()
{
targetObjectDestroyLink();
delink();
iRefTo = NULL;
iRefFrom = NULL;
}
// Link is invalid due to destruction of referenced target object. Call comes from the refTo object
// Tell our refFrom object, that the link is cut
void invalidate() // the iRefFrom MUST remain!!
{
sourceObjectDestroyLink(); delink(); iRefTo = NULL;
sourceObjectDestroyLink();
delink();
iRefTo = NULL;
}
bool isValid() const // Only check the iRefTo
@ -88,4 +107,5 @@ template <class TO, class FROM> class Reference : public LinkedListElement
};
//=====================================================
#endif

1
src/framework/Utilities/TypeList.h
View file

@ -40,4 +40,5 @@ struct TypeList
#define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3) >
#define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TYPELIST_3(T2, T3, T4) >
#define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TYPELIST_4(T2, T3, T4, T5) >
#endif

7
src/framework/Utilities/UnorderedMap.h
View file

@ -52,11 +52,14 @@ using std::hash_map;
namespace __gnu_cxx
{
template<> struct hash<unsigned long long>
template<>
struct hash<unsigned long long>
{
size_t operator()(const unsigned long long &__x) const { return (size_t)__x; }
};
template<typename T> struct hash<T *>
template<typename T>
struct hash<T *>
{
size_t operator()(T * const &__x) const { return (size_t)__x; }
};

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__
#define __REVISION_NR_H__
#define REVISION_NR "9774"
#define REVISION_NR "9775"
#endif // __REVISION_NR_H__