mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-12 19: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

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

@ -42,13 +42,13 @@ template
< <
class ACTIVE_OBJECT, class ACTIVE_OBJECT,
class WORLD_OBJECT_TYPES, class WORLD_OBJECT_TYPES,
class GRID_OBJECT_TYPES, class GRID_OBJECT_TYPES
class ThreadModel = MaNGOS::SingleThreaded<ACTIVE_OBJECT>
> >
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:
/** destructor to clean up its resources. This includes unloading the /** 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 /** 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); return i_objects.template insert<SPECIFIC_OBJECT>(obj);
} }
/** an object of interested exits the grid /** 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); 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 /** 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); visitor.Visit(i_container);
} }
/** Grid visitor for world objects /** 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); visitor.Visit(i_objects);
} }
/** Returns the number of object within the grid. /** 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. /** 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()) if (obj->isActiveObject())
m_activeGridObjects.insert(obj); m_activeGridObjects.insert(obj);
return i_container.template insert<SPECIFIC_OBJECT>(obj); return i_container.template insert<SPECIFIC_OBJECT>(obj);
} }
/** Removes a containter type object from the grid /** 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()) if (obj->isActiveObject())
m_activeGridObjects.erase(obj); m_activeGridObjects.erase(obj);
return i_container.template remove<SPECIFIC_OBJECT>(obj); return i_container.template remove<SPECIFIC_OBJECT>(obj);
} }
private: private:
typedef typename ThreadModel::Lock Guard;
typedef typename ThreadModel::VolatileType VolatileType;
TypeMapContainer<GRID_OBJECT_TYPES> i_container; TypeMapContainer<GRID_OBJECT_TYPES> i_container;
TypeMapContainer<WORLD_OBJECT_TYPES> i_objects; TypeMapContainer<WORLD_OBJECT_TYPES> i_objects;
typedef std::set<void*> ActiveGridObjects; typedef std::set<void*> ActiveGridObjects;
ActiveGridObjects m_activeGridObjects; ActiveGridObjects m_activeGridObjects;
}; };
#endif #endif

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

@ -47,30 +47,26 @@ 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)
{ {
grid.LockGrid();
loader.Load(grid); loader.Load(grid);
grid.UnlockGrid();
} }
/** 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)
{ {
grid.LockGrid();
stoper.Stop(grid); stoper.Stop(grid);
grid.UnlockGrid();
} }
/** 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)
{ {
grid.LockGrid();
unloader.Unload(grid); unloader.Unload(grid);
grid.UnlockGrid();
} }
}; };
#endif #endif

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

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

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

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

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

@ -28,27 +28,42 @@
class GridInfo class GridInfo
{ {
public: public:
GridInfo()
: 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) {}
const TimeTracker& getTimeTracker() const { return i_timer; }
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; }
void decUnloadActiveLock() { if(i_unloadActiveLockCount) --i_unloadActiveLockCount; }
void setTimer(const TimeTracker& pTimer) { i_timer = pTimer; } GridInfo()
void ResetTimeTracker(time_t interval) { i_timer.Reset(interval); } : i_timer(0), i_unloadActiveLockCount(0), i_unloadExplicitLock(false),
void UpdateTimeTracker(time_t diff) { i_timer.Update(diff); } i_unloadReferenceLock(false)
{
}
private: GridInfo(time_t expiry, bool unload = true )
TimeTracker i_timer; : i_timer(expiry), i_unloadActiveLockCount(0), i_unloadExplicitLock(!unload),
uint16 i_unloadActiveLockCount : 16; // lock from active object spawn points (prevent clone loading) i_unloadReferenceLock(false)
bool i_unloadExplicitLock : 1; // explicit manual lock or config setting {
bool i_unloadReferenceLock : 1; // lock from instance map copy }
const TimeTracker& getTimeTracker() const { return i_timer; }
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; }
void decUnloadActiveLock() { if (i_unloadActiveLockCount) --i_unloadActiveLockCount; }
void setTimer(const TimeTracker& pTimer) { i_timer = pTimer; }
void ResetTimeTracker(time_t interval) { i_timer.Reset(interval); }
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
bool i_unloadReferenceLock : 1; // lock from instance map copy
}; };
typedef enum typedef enum
@ -56,104 +71,112 @@ typedef enum
GRID_STATE_INVALID = 0, GRID_STATE_INVALID = 0,
GRID_STATE_ACTIVE = 1, GRID_STATE_ACTIVE = 1,
GRID_STATE_IDLE = 2, GRID_STATE_IDLE = 2,
GRID_STATE_REMOVAL= 3, GRID_STATE_REMOVAL = 3,
MAX_GRID_STATE = 4 MAX_GRID_STATE = 4
} grid_state_t; } grid_state_t;
template template
< <
unsigned int 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 ThreadModel = MaNGOS::SingleThreaded<ACTIVE_OBJECT>
> >
class MANGOS_DLL_DECL NGrid class MANGOS_DLL_DECL NGrid
{ {
public: public:
typedef Grid<ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES, ThreadModel> GridType; typedef Grid<ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> GridType;
NGrid(uint32 id, int32 x, int32 y, time_t expiry, bool unload = true)
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_gridId(id), i_x(x), i_y(y), i_cellstate(GRID_STATE_INVALID), i_GridObjectDataLoaded(false)
{ {
i_GridInfo = GridInfo(expiry, unload); 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(x < N);
ASSERT(y < N); ASSERT(y < N);
return i_cells[x][y]; return i_cells[x][y];
} }
GridType& operator()(unsigned short x, unsigned short y) GridType& operator()(uint32 x, uint32 y)
{ {
ASSERT(x < N); ASSERT(x < N);
ASSERT(y < N); ASSERT(y < N);
return i_cells[x][y]; 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; } 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; } void SetGridState(grid_state_t s) { i_cellstate = s; }
int32 getX() const { return i_x; } uint32 getX() const { return i_x; }
int32 getY() const { return i_y; } 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); i_Reference.link(pTo, this);
} }
bool isGridObjectDataLoaded() const { return i_GridObjectDataLoaded; } bool isGridObjectDataLoaded() const { return i_GridObjectDataLoaded; }
void setGridObjectDataLoaded(bool pLoaded) { i_GridObjectDataLoaded = pLoaded; } void setGridObjectDataLoaded(bool pLoaded) { i_GridObjectDataLoaded = pLoaded; }
GridInfo* getGridInfoRef() { return &i_GridInfo; } GridInfo* getGridInfoRef() { return &i_GridInfo; }
const TimeTracker& getTimeTracker() const { return i_GridInfo.getTimeTracker(); } const TimeTracker& getTimeTracker() const { return i_GridInfo.getTimeTracker(); }
bool getUnloadLock() const { return i_GridInfo.getUnloadLock(); } bool getUnloadLock() const { return i_GridInfo.getUnloadLock(); }
void setUnloadExplicitLock( bool on ) { i_GridInfo.setUnloadExplicitLock(on); } void setUnloadExplicitLock(bool on) { i_GridInfo.setUnloadExplicitLock(on); }
void setUnloadReferenceLock( bool on ) { i_GridInfo.setUnloadReferenceLock(on); } void setUnloadReferenceLock(bool on) { i_GridInfo.setUnloadReferenceLock(on); }
void incUnloadActiveLock() { i_GridInfo.incUnloadActiveLock(); } void incUnloadActiveLock() { i_GridInfo.incUnloadActiveLock(); }
void decUnloadActiveLock() { i_GridInfo.decUnloadActiveLock(); } void decUnloadActiveLock() { i_GridInfo.decUnloadActiveLock(); }
void ResetTimeTracker(time_t interval) { i_GridInfo.ResetTimeTracker(interval); } void ResetTimeTracker(time_t interval) { i_GridInfo.ResetTimeTracker(interval); }
void UpdateTimeTracker(time_t diff) { i_GridInfo.UpdateTimeTracker(diff); } 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); 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); 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 (uint32 x = 0; x < N; ++x)
for(unsigned int y=0; y < N; ++y) for (uint32 y = 0; y < N; ++y)
i_cells[x][y].Visit(visitor); 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); getGridType(x, y).Visit(visitor);
} }
unsigned int ActiveObjectsInGrid(void) const uint32 ActiveObjectsInGrid() const
{ {
unsigned int count=0; uint32 count = 0;
for(unsigned int x=0; x < N; ++x) for (uint32 x = 0; x < N; ++x)
for(unsigned int y=0; y < N; ++y) for (uint32 y = 0; y < N; ++y)
count += i_cells[x][y].ActiveObjectsInGrid(); count += i_cells[x][y].ActiveObjectsInGrid();
return count; 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); 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); return getGridType(x, y).RemoveGridObject(obj);
} }
@ -169,11 +192,12 @@ class MANGOS_DLL_DECL NGrid
uint32 i_gridId; uint32 i_gridId;
GridInfo i_GridInfo; GridInfo i_GridInfo;
GridReference<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES, ThreadModel> > i_Reference; GridReference<NGrid<N, ACTIVE_OBJECT, WORLD_OBJECT_TYPES, GRID_OBJECT_TYPES> > i_Reference;
int32 i_x; uint32 i_x;
int32 i_y; uint32 i_y;
grid_state_t i_cellstate; grid_state_t i_cellstate;
GridType i_cells[N][N]; GridType i_cells[N][N];
bool i_GridObjectDataLoaded; bool i_GridObjectDataLoaded;
}; };
#endif #endif

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

@ -31,14 +31,19 @@
#include "Utilities/UnorderedMap.h" #include "Utilities/UnorderedMap.h"
#include "GameSystem/GridRefManager.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; 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<H, KEY_TYPE> _elements;
ContainerUnorderedMap<T, KEY_TYPE> _TailElements; ContainerUnorderedMap<T, KEY_TYPE> _TailElements;
@ -48,24 +53,33 @@ template<class OBJECT_TYPES, class KEY_TYPE = OBJECT_HANDLE>
class TypeUnorderedMapContainer class TypeUnorderedMapContainer
{ {
public: 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); 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); 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); return TypeUnorderedMapContainer::find(i_elements, hdl, (SPECIFIC_TYPE*)NULL);
} }
private: private:
ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> i_elements; ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> i_elements;
// Helpers // Helpers
// Insert 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); typename UNORDERED_MAP<KEY_TYPE, SPECIFIC_TYPE*>::iterator i = elements._element.find(handle);
if (i == elements._element.end()) if (i == elements._element.end())
@ -75,25 +89,33 @@ class TypeUnorderedMapContainer
} }
else 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; 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; 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; 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); bool ret = TypeUnorderedMapContainer::insert(elements._elements, handle, obj);
return ret ? ret : TypeUnorderedMapContainer::insert(elements._TailElements, handle, obj); return ret ? ret : TypeUnorderedMapContainer::insert(elements._TailElements, handle, obj);
} }
// Find helpers // 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); typename UNORDERED_MAP<KEY_TYPE, SPECIFIC_TYPE*>::iterator i = elements._element.find(hdl);
if (i == elements._element.end()) if (i == elements._element.end())
@ -101,35 +123,49 @@ class TypeUnorderedMapContainer
else else
return i->second; 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; 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; 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); SPECIFIC_TYPE* ret = TypeUnorderedMapContainer::find(elements._elements, hdl, (SPECIFIC_TYPE*)NULL);
return ret ? ret : TypeUnorderedMapContainer::find(elements._TailElements, hdl, (SPECIFIC_TYPE*)NULL); return ret ? ret : TypeUnorderedMapContainer::find(elements._TailElements, hdl, (SPECIFIC_TYPE*)NULL);
} }
// Erase helpers // 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); elements._element.erase(handle);
return true; 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; 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; 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); bool ret = TypeUnorderedMapContainer::erase(elements._elements, handle, (SPECIFIC_TYPE*)NULL);
return ret ? ret : TypeUnorderedMapContainer::erase(elements._TailElements, 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, * By itself its meaningless but collaborate along with TypeContainers,
* it become the most powerfully container in the whole system. * it become the most powerfully container in the whole system.
*/ */
template<class OBJECT> struct ContainerMapList template<class OBJECT>
struct ContainerMapList
{ {
GridRefManager<OBJECT> _element; 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<H> _elements;
ContainerMapList<T> _TailElements; ContainerMapList<T> _TailElements;
}; };
#include "TypeContainerFunctions.h" #include "TypeContainerFunctions.h"
/* /*
@ -169,26 +208,32 @@ template<class OBJECT_TYPES>
class MANGOS_DLL_DECL TypeMapContainer class MANGOS_DLL_DECL TypeMapContainer
{ {
public: 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 /// 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); SPECIFIC_TYPE* t = MaNGOS::Insert(i_elements, obj);
return (t != NULL); return (t != NULL);
} }
/// Removes the object from the container, and returns the removed object /// 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); SPECIFIC_TYPE* t = MaNGOS::Remove(i_elements, obj);
return (t != NULL); return (t != NULL);
} }
ContainerMapList<OBJECT_TYPES> & GetElements(void) { return i_elements; } ContainerMapList<OBJECT_TYPES> & GetElements() { return i_elements; }
const ContainerMapList<OBJECT_TYPES> & GetElements(void) const { return i_elements;} const ContainerMapList<OBJECT_TYPES> & GetElements() const { return i_elements;}
private: private:
ContainerMapList<OBJECT_TYPES> i_elements; ContainerMapList<OBJECT_TYPES> i_elements;
}; };
#endif #endif

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

@ -33,81 +33,94 @@ namespace MaNGOS
{ {
/* ContainerMapList Helpers */ /* ContainerMapList Helpers */
// count functions // 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(); 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; 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; 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); 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); return Count(elements._TailElements, fake);
} }
// non-const insert functions // 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; //elements._element[hdl] = obj;
obj->GetGridRef().link(&elements._element, obj); obj->GetGridRef().link(&elements._element, obj);
return 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; return NULL;
} }
// this is a missed // 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 return NULL; // a missed
} }
// Recursion // 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); SPECIFIC_TYPE* t= Insert(elements._elements, obj);
return (t != NULL ? t : Insert(elements._TailElements, obj)); return (t != NULL ? t : Insert(elements._TailElements, obj));
} }
// non-const remove method // 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(); obj->GetGridRef().unlink();
return obj; 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; return NULL;
} }
// this is a missed // 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 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 // 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) );
} }
} }
#endif #endif

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

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

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

@ -27,20 +27,28 @@ namespace MaNGOS
/** /**
* OperatorNew policy creates an object on the heap using new. * OperatorNew policy creates an object on the heap using new.
*/ */
template <class T> template<class T>
class MANGOS_DLL_DECL OperatorNew class MANGOS_DLL_DECL OperatorNew
{ {
public: 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;
}
}; };
/** /**
* LocalStaticCreation policy creates an object on the stack * LocalStaticCreation policy creates an object on the stack
* the first time call Create. * the first time call Create.
*/ */
template <class T> template<class T>
class MANGOS_DLL_DECL LocalStaticCreation class MANGOS_DLL_DECL LocalStaticCreation
{ {
union MaxAlign union MaxAlign
{ {
@ -55,34 +63,43 @@ namespace MaNGOS
int Test::* pMember_; int Test::* pMember_;
int (Test::*pMemberFn_)(int); int (Test::*pMemberFn_)(int);
}; };
public: public:
static T* Create(void)
static T* Create()
{ {
static MaxAlign si_localStatic; static MaxAlign si_localStatic;
return new(&si_localStatic) T; return new(&si_localStatic) T;
} }
static void Destroy(T *obj) { obj->~T(); } static void Destroy(T *obj)
{
obj->~T();
}
}; };
/** /**
* CreateUsingMalloc by pass the memory manger. * CreateUsingMalloc by pass the memory manger.
*/ */
template<class T> template<class T>
class MANGOS_DLL_DECL CreateUsingMalloc class MANGOS_DLL_DECL CreateUsingMalloc
{ {
public: public:
static T* Create() static T* Create()
{ {
void* p = ::malloc(sizeof(T)); void* p = malloc(sizeof(T));
if (!p) return 0;
if (!p)
return NULL;
return new(p) T; return new(p) T;
} }
static void Destroy(T* p) static void Destroy(T* p)
{ {
p->~T(); p->~T();
::free(p); free(p);
} }
}; };
@ -90,7 +107,7 @@ namespace MaNGOS
* CreateOnCallBack creates the object base on the call back. * CreateOnCallBack creates the object base on the call back.
*/ */
template<class T, class CALL_BACK> template<class T, class CALL_BACK>
class MANGOS_DLL_DECL CreateOnCallBack class MANGOS_DLL_DECL CreateOnCallBack
{ {
public: public:
static T* Create() static T* Create()
@ -104,4 +121,5 @@ namespace MaNGOS
} }
}; };
} }
#endif #endif

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

@ -22,17 +22,23 @@
#include "../../dep/tbb/include/tbb/scalable_allocator.h" #include "../../dep/tbb/include/tbb/scalable_allocator.h"
void * operator new(size_t sz) void* operator new(size_t sz)
{ {
void *res = scalable_malloc(sz); void *res = scalable_malloc(sz);
if (NULL == res) throw std::bad_alloc();
if (res == NULL)
throw std::bad_alloc();
return res; return res;
} }
void* operator new[](size_t sz) void* operator new[](size_t sz)
{ {
void *res = scalable_malloc(sz); void *res = scalable_malloc(sz);
if (NULL == res) throw std::bad_alloc();
if (res == NULL)
throw std::bad_alloc();
return res; return res;
} }

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

@ -23,10 +23,10 @@ namespace MaNGOS
{ {
extern "C" void external_wrapper(void *p) extern "C" void external_wrapper(void *p)
{ {
std::atexit( (void (*)())p ); std::atexit((void (*)())p);
} }
void MANGOS_DLL_SPEC at_exit( void (*func)() ) void MANGOS_DLL_SPEC at_exit(void (*func)())
{ {
external_wrapper((void*)func); external_wrapper((void*)func);
} }

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

@ -26,25 +26,26 @@ typedef void (* Destroyer)(void);
namespace MaNGOS namespace MaNGOS
{ {
void MANGOS_DLL_SPEC at_exit( void (*func)() ); void MANGOS_DLL_SPEC at_exit(void (*func)());
template <class T> template<class T>
class MANGOS_DLL_DECL ObjectLifeTime class MANGOS_DLL_DECL ObjectLifeTime
{ {
public: public:
static void ScheduleCall(void (*destroyer)() )
static void ScheduleCall(void (*destroyer)())
{ {
at_exit( destroyer ); at_exit(destroyer);
} }
DECLSPEC_NORETURN static void OnDeadReference(void) ATTR_NORETURN; DECLSPEC_NORETURN static void OnDeadReference() ATTR_NORETURN;
}; };
template <class T> 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"); throw std::runtime_error("Dead Reference");
} }
} }
#endif #endif

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

@ -30,25 +30,29 @@
namespace MaNGOS 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:
static T& Instance(); static T& Instance();
protected: protected:
Singleton() {};
Singleton()
{
}
private: private:
// Prohibited actions...this does not prevent hijacking. // Prohibited actions...this does not prevent hijacking.
Singleton(const Singleton &); Singleton(const Singleton&);
Singleton& operator=(const Singleton &); Singleton& operator=(const Singleton&);
// Singleton Helpers // Singleton Helpers
static void DestroySingleton(); static void DestroySingleton();
@ -59,4 +63,5 @@ namespace MaNGOS
static bool si_destroyed; static bool si_destroyed;
}; };
} }
#endif #endif

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

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

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

@ -28,12 +28,13 @@
namespace MaNGOS namespace MaNGOS
{ {
inline void Guard(void *) {} template<typename MUTEX>
class MANGOS_DLL_DECL GeneralLock
template<typename MUTEX> class MANGOS_DLL_DECL GeneralLock
{ {
public: public:
GeneralLock(MUTEX &m) : i_mutex(m)
GeneralLock(MUTEX &m)
: i_mutex(m)
{ {
i_mutex.acquire(); i_mutex.acquire();
} }
@ -42,79 +43,107 @@ namespace MaNGOS
{ {
i_mutex.release(); i_mutex.release();
} }
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>
class MANGOS_DLL_DECL SingleThreaded class MANGOS_DLL_DECL SingleThreaded
{ {
public: public:
struct Lock // empty object struct Lock // empty object
{ {
Lock() {} Lock()
Lock(const T &) {} {
Lock(const SingleThreaded<T> &) // for single threaded we ignore this }
Lock(const T&)
{
}
Lock(const SingleThreaded<T>&) // for single threaded we ignore this
{ {
} }
}; };
typedef T VolatileType;
}; };
// object level lockable
template<class T, class MUTEX> template<class T, class MUTEX>
class MANGOS_DLL_DECL ObjectLevelLockable class MANGOS_DLL_DECL ObjectLevelLockable
{ {
public: public:
ObjectLevelLockable() : i_mtx() {}
ObjectLevelLockable()
: i_mtx()
{
}
friend class Lock; friend class Lock;
class Lock class Lock
{ {
public: public:
Lock(ObjectLevelLockable<T, MUTEX> &host) : i_lock(host.i_mtx)
Lock(ObjectLevelLockable<T, MUTEX> &host)
: i_lock(host.i_mtx)
{ {
} }
private: private:
GeneralLock<MUTEX> i_lock; GeneralLock<MUTEX> i_lock;
}; };
typedef volatile T VolatileType;
private: private:
// prevent the compiler creating a copy construct // prevent the compiler creating a copy construct
ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX> &); ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX> &); ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
MUTEX i_mtx; MUTEX i_mtx;
}; };
template<class T, class MUTEX> template<class T, class MUTEX>
class MANGOS_DLL_DECL ClassLevelLockable class MANGOS_DLL_DECL ClassLevelLockable
{ {
public: public:
class Lock;
friend class Lock;
typedef volatile T VolatileType;
ClassLevelLockable() {} ClassLevelLockable()
{
}
friend class Lock;
class Lock class Lock
{ {
public: public:
Lock(T& /*host*/) { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); }
Lock(ClassLevelLockable<T, MUTEX> &) { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); } Lock(T& /*host*/)
Lock() { ClassLevelLockable<T, MUTEX>::si_mtx.acquire(); } {
~Lock() { ClassLevelLockable<T, MUTEX>::si_mtx.release(); } 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: private:
static MUTEX si_mtx; static MUTEX si_mtx;
}; };
@ -122,6 +151,7 @@ namespace MaNGOS
template<class T, class MUTEX> MUTEX MaNGOS::ClassLevelLockable<T, MUTEX>::si_mtx; template<class T, class MUTEX> MUTEX MaNGOS::ClassLevelLockable<T, MUTEX>::si_mtx;
#define INSTANTIATE_CLASS_MUTEX(CTYPE,MUTEX) \ #define INSTANTIATE_CLASS_MUTEX(CTYPE, MUTEX) \
template class MANGOS_DLL_DECL MaNGOS::ClassLevelLockable<CTYPE, MUTEX > template class MANGOS_DLL_DECL MaNGOS::ClassLevelLockable<CTYPE, MUTEX>
#endif #endif

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

@ -23,13 +23,13 @@
for cross platform where they have different endians. for cross platform where they have different endians.
*/ */
#include<Platform/Define.h> #include <Platform/Define.h>
#include<algorithm> #include <algorithm>
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);
@ -38,7 +38,8 @@ namespace ByteConverter
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> inline void apply(T *val) template<typename T>
inline void apply(T *val)
{ {
convert<sizeof(T)>((char *)(val)); convert<sizeof(T)>((char *)(val));
} }
@ -56,7 +57,7 @@ template<typename T> void EndianConvert(T*); // will generate link error
template<typename T> void EndianConvertReverse(T*); // will generate link error 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&) { }

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

@ -23,10 +23,11 @@
namespace MaNGOS namespace MaNGOS
{ {
template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void > template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
class _Callback class _Callback
{ {
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;
@ -35,17 +36,27 @@ namespace MaNGOS
ParamType3 m_param3; ParamType3 m_param3;
ParamType4 m_param4; ParamType4 m_param4;
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3, m_param4); } void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3, m_param4); }
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_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4) {} : m_object(object), m_method(method),
_Callback(_Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb) m_param1(param1), m_param2(param2), m_param3(param3), m_param4(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) {} {
}
_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)
{
}
}; };
template < class Class, typename ParamType1, typename ParamType2, typename ParamType3 > template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
class _Callback < Class, ParamType1, ParamType2, ParamType3 > class _Callback<Class, ParamType1, ParamType2, ParamType3>
{ {
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;
@ -53,67 +64,102 @@ namespace MaNGOS
ParamType2 m_param2; ParamType2 m_param2;
ParamType3 m_param3; ParamType3 m_param3;
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_param1(param1), m_param2(param2) {} : m_object(object), m_method(method),
_Callback(_Callback < Class, ParamType1, ParamType2, ParamType3 > const& cb) m_param1(param1), m_param2(param2)
: m_object(cb.object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3) {} {
}
_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)
{
}
}; };
template < class Class, typename ParamType1, typename ParamType2 > template<class Class, typename ParamType1, typename ParamType2>
class _Callback < Class, ParamType1, ParamType2 > class _Callback<Class, ParamType1, ParamType2>
{ {
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;
void _Execute() { (m_object->*m_method)(m_param1, m_param2); } void _Execute() { (m_object->*m_method)(m_param1, m_param2); }
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_param1(param1), m_param2(param2) {} : m_object(object), m_method(method),
_Callback(_Callback < Class, ParamType1, ParamType2 > const& cb) m_param1(param1), m_param2(param2)
: m_object(cb.m_object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_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)
{
}
}; };
template < class Class, typename ParamType1 > template<class Class, typename ParamType1>
class _Callback < Class, ParamType1 > class _Callback<Class, ParamType1>
{ {
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_param1(param1) {} : m_object(object), m_method(method),
_Callback(_Callback < Class, ParamType1 > const& cb) m_param1(param1)
: m_object(cb.m_object), m_method(cb.m_method), m_param1(cb.m_param1) {} {
}
_Callback(_Callback<Class, ParamType1> const& cb)
: m_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1)
{
}
}; };
template < class Class > template<class Class>
class _Callback < Class > class _Callback<Class>
{ {
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)
_Callback(_Callback < Class > const& cb) {
: m_object(cb.m_object), m_method(cb.m_method) {} }
_Callback(_Callback<Class> const& cb)
: m_object(cb.m_object), m_method(cb.m_method)
{
}
}; };
/// ---- Statics ---- /// ---- Statics ----
template < typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void > template<typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
class _SCallback class _SCallback
{ {
protected: protected:
typedef void (*Method)(ParamType1, ParamType2, ParamType3, ParamType4); typedef void (*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
@ -121,73 +167,116 @@ namespace MaNGOS
ParamType3 m_param3; ParamType3 m_param3;
ParamType4 m_param4; ParamType4 m_param4;
void _Execute() { (*m_method)(m_param1, m_param2, m_param3, m_param4); } void _Execute() { (*m_method)(m_param1, m_param2, m_param3, m_param4); }
public: public:
_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_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4) {} : m_method(method),
_SCallback(_SCallback < ParamType1, ParamType2, ParamType3, ParamType4> const& cb) m_param1(param1), m_param2(param2), m_param3(param3), m_param4(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) {} {
}
_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)
{
}
}; };
template < typename ParamType1, typename ParamType2, typename ParamType3 > template<typename ParamType1, typename ParamType2, typename ParamType3>
class _SCallback < ParamType1, ParamType2, ParamType3 > class _SCallback<ParamType1, ParamType2, ParamType3>
{ {
protected: protected:
typedef void (*Method)(ParamType1, ParamType2, ParamType3); typedef void (*Method)(ParamType1, ParamType2, ParamType3);
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
ParamType2 m_param2; ParamType2 m_param2;
ParamType3 m_param3; ParamType3 m_param3;
void _Execute() { (*m_method)(m_param1, m_param2, m_param3); } void _Execute() { (*m_method)(m_param1, m_param2, m_param3); }
public: public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3) _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_method(method), m_param1(param1), m_param2(param2), m_param3(param3) {} : m_method(method),
_SCallback(_SCallback < ParamType1, ParamType2, ParamType3 > const& cb) m_param1(param1), m_param2(param2), m_param3(param3)
: m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_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)
{
}
}; };
template < typename ParamType1, typename ParamType2 > template<typename ParamType1, typename ParamType2>
class _SCallback < ParamType1, ParamType2 > class _SCallback<ParamType1, ParamType2>
{ {
protected: protected:
typedef void (*Method)(ParamType1, ParamType2); typedef void (*Method)(ParamType1, ParamType2);
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
ParamType2 m_param2; ParamType2 m_param2;
void _Execute() { (*m_method)(m_param1, m_param2); } void _Execute() { (*m_method)(m_param1, m_param2); }
public: public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2) _SCallback(Method method, ParamType1 param1, ParamType2 param2)
: m_method(method), m_param1(param1), m_param2(param2) {} : m_method(method),
_SCallback(_SCallback < ParamType1, ParamType2 > const& cb) m_param1(param1), m_param2(param2)
: m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2) {} {
}
_SCallback(_SCallback<ParamType1, ParamType2> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2)
{
}
}; };
template < typename ParamType1 > template<typename ParamType1>
class _SCallback < ParamType1 > class _SCallback<ParamType1>
{ {
protected: protected:
typedef void (*Method)(ParamType1); typedef void (*Method)(ParamType1);
Method m_method; Method m_method;
ParamType1 m_param1; ParamType1 m_param1;
void _Execute() { (*m_method)(m_param1); } void _Execute() { (*m_method)(m_param1); }
public: public:
_SCallback(Method method, ParamType1 param1) _SCallback(Method method, ParamType1 param1)
: m_method(method), m_param1(param1) {} : m_method(method),
_SCallback(_SCallback < ParamType1 > const& cb) m_param1(param1)
: m_method(cb.m_method), m_param1(cb.m_param1) {} {
}
_SCallback(_SCallback<ParamType1> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1)
{
}
}; };
template < > template<>
class _SCallback < > class _SCallback<>
{ {
protected: protected:
typedef void (*Method)(); typedef void (*Method)();
Method m_method; Method m_method;
void _Execute() { (*m_method)(); } void _Execute() { (*m_method)(); }
public: public:
_SCallback(Method method) _SCallback(Method method)
: m_method(method) {} : m_method(method)
_SCallback(_SCallback <> const& cb) {
: m_method(cb.m_method) {} }
_SCallback(_SCallback<> const& cb)
: m_method(cb.m_method)
{
}
}; };
} }
@ -198,70 +287,93 @@ namespace MaNGOS
class ICallback class ICallback
{ {
public: public:
virtual void Execute() = 0; virtual void Execute() = 0;
virtual ~ICallback() {} virtual ~ICallback() {}
}; };
template < class CB > template<class CB>
class _ICallback : public CB, public ICallback class _ICallback : public CB, public ICallback
{ {
public: public:
_ICallback(CB const& cb) : CB(cb) {}
_ICallback(CB const& cb) : CB(cb)
{
}
void Execute() { CB::_Execute(); } void Execute() { CB::_Execute(); }
}; };
template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void > template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
class Callback : class Callback : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> >
public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4 > >
{ {
private: private:
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))
{
}
}; };
template < class Class, typename ParamType1, typename ParamType2, typename ParamType3 > template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
class Callback < Class, ParamType1, ParamType2, ParamType3 > : class Callback<Class, ParamType1, ParamType2, ParamType3> : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3> >
public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3 > >
{ {
private: private:
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))
{
}
}; };
template < class Class, typename ParamType1, typename ParamType2 > template<class Class, typename ParamType1, typename ParamType2>
class Callback < Class, ParamType1, ParamType2 > : class Callback<Class, ParamType1, ParamType2> : public _ICallback<_Callback<Class, ParamType1, ParamType2> >
public _ICallback< _Callback < Class, ParamType1, ParamType2 > >
{ {
private: private:
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))
{
}
}; };
template < class Class, typename ParamType1 > template<class Class, typename ParamType1>
class Callback < Class, ParamType1 > : class Callback<Class, ParamType1> : public _ICallback<_Callback<Class, ParamType1> >
public _ICallback< _Callback < Class, ParamType1 > >
{ {
private: private:
typedef _Callback < Class, ParamType1 > C1;
typedef _Callback<Class, ParamType1> C1;
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))
{
}
}; };
template < class Class > template<class Class>
class Callback < Class > : public _ICallback< _Callback < Class > > class Callback<Class> : public _ICallback<_Callback<Class> >
{ {
private: private:
typedef _Callback < Class > C0;
typedef _Callback<Class> C0;
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))
{
}
}; };
} }
@ -274,108 +386,146 @@ namespace MaNGOS
class IQueryCallback class IQueryCallback
{ {
public: public:
virtual void Execute() = 0; virtual void Execute() = 0;
virtual ~IQueryCallback() {} virtual ~IQueryCallback() {}
virtual void SetResult(QueryResult* result) = 0; virtual void SetResult(QueryResult* result) = 0;
virtual QueryResult* GetResult() = 0; virtual QueryResult* GetResult() = 0;
}; };
template < class CB > template<class CB>
class _IQueryCallback : public CB, public IQueryCallback class _IQueryCallback : public CB, public IQueryCallback
{ {
public: public:
_IQueryCallback(CB const& cb) : CB(cb) {}
_IQueryCallback(CB const& cb) : CB(cb)
{
}
void Execute() { CB::_Execute(); } void Execute() { CB::_Execute(); }
void SetResult(QueryResult* result) { CB::m_param1 = result; } void SetResult(QueryResult* result) { CB::m_param1 = result; }
QueryResult* GetResult() { return CB::m_param1; } QueryResult* GetResult() { return CB::m_param1; }
}; };
template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void > template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
class QueryCallback : class QueryCallback : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> >
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2, ParamType3 > >
{ {
private: private:
typedef _Callback < Class, QueryResult*, ParamType1, ParamType2, ParamType3 > QC3;
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
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))
{
}
}; };
template < class Class, typename ParamType1, typename ParamType2 > template<class Class, typename ParamType1, typename ParamType2>
class QueryCallback < Class, ParamType1, ParamType2 > : class QueryCallback<Class, ParamType1, ParamType2> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2> >
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2 > >
{ {
private: private:
typedef _Callback < Class, QueryResult*, ParamType1, ParamType2 > QC2;
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2> QC2;
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))
{
}
}; };
template < class Class, typename ParamType1 > template<class Class, typename ParamType1>
class QueryCallback < Class, ParamType1 > : class QueryCallback<Class, ParamType1> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1> >
public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1 > >
{ {
private: private:
typedef _Callback < Class, QueryResult*, ParamType1 > QC1;
typedef _Callback<Class, QueryResult*, ParamType1> QC1;
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))
{
}
}; };
template < class Class > template<class Class>
class QueryCallback < Class > : public _IQueryCallback< _Callback < Class, QueryResult* > > class QueryCallback<Class> : public _IQueryCallback<_Callback<Class, QueryResult*> >
{ {
private: private:
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))
{
}
}; };
/// ---- Statics ---- /// ---- Statics ----
template < typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void > template<typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
class SQueryCallback : class SQueryCallback : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> >
public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2, ParamType3 > >
{ {
private: private:
typedef _SCallback < QueryResult*, ParamType1, ParamType2, ParamType3 > QC3;
typedef _SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
public: public:
SQueryCallback(typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3) 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 > template<typename ParamType1, typename ParamType2>
class SQueryCallback < ParamType1, ParamType2 > : class SQueryCallback < ParamType1, ParamType2 > : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2> >
public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2 > >
{ {
private: private:
typedef _SCallback < QueryResult*, ParamType1, ParamType2 > QC2;
typedef _SCallback<QueryResult*, ParamType1, ParamType2> QC2;
public: public:
SQueryCallback(typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2) 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 > template<typename ParamType1>
class SQueryCallback < ParamType1 > : class SQueryCallback<ParamType1> : public _IQueryCallback<_SCallback<QueryResult*, ParamType1> >
public _IQueryCallback< _SCallback < QueryResult*, ParamType1 > >
{ {
private: private:
typedef _SCallback < QueryResult*, ParamType1 > QC1;
typedef _SCallback<QueryResult*, ParamType1> QC1;
public: public:
SQueryCallback(typename QC1::Method method, QueryResult* result, ParamType1 param1) SQueryCallback(typename QC1::Method method, QueryResult* result, ParamType1 param1)
: _IQueryCallback< QC1 >(QC1(method, result, param1)) {} : _IQueryCallback<QC1>(QC1(method, result, param1))
{
}
}; };
template < > template<>
class SQueryCallback < > : public _IQueryCallback< _SCallback < QueryResult* > > class SQueryCallback<> : public _IQueryCallback<_SCallback<QueryResult*> >
{ {
private: private:
typedef _SCallback < QueryResult* > QC0;
typedef _SCallback<QueryResult*> QC0;
public: public:
SQueryCallback(QC0::Method method, QueryResult* result) SQueryCallback(QC0::Method method, QueryResult* result)
: _IQueryCallback< QC0 >(QC0(method, result)) {} : _IQueryCallback<QC0>(QC0(method, result))
{
}
}; };
} }

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

@ -71,28 +71,30 @@ void EventProcessor::KillAllEvents(bool force)
i_old->second->to_Abort = true; i_old->second->to_Abort = true;
i_old->second->Abort(m_time); i_old->second->Abort(m_time);
if(force || i_old->second->IsDeletable()) if (force || i_old->second->IsDeletable())
{ {
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);
} }
} }
// fast clear event list (in force case) // fast clear event list (in force case)
if(force) if (force)
m_events.clear(); m_events.clear();
} }
void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime) 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; Event->m_execTime = e_time;
m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event)); m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event));
} }
uint64 EventProcessor::CalculateTime(uint64 t_offset) uint64 EventProcessor::CalculateTime(uint64 t_offset)
{ {
return(m_time + t_offset); return m_time + t_offset;
} }

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

@ -21,14 +21,19 @@
#include "Platform/Define.h" #include "Platform/Define.h"
#include<map> #include <map>
// Note. All times are in milliseconds here. // Note. All times are in milliseconds here.
class BasicEvent class BasicEvent
{ {
public: public:
BasicEvent() { to_Abort = false; }
BasicEvent()
: to_Abort(false)
{
}
virtual ~BasicEvent() // override destructor to perform some actions on event removal virtual ~BasicEvent() // override destructor to perform some actions on event removal
{ {
}; };
@ -55,6 +60,7 @@ typedef std::multimap<uint64, BasicEvent*> EventList;
class EventProcessor class EventProcessor
{ {
public: public:
EventProcessor(); EventProcessor();
~EventProcessor(); ~EventProcessor();
@ -62,9 +68,12 @@ class EventProcessor
void KillAllEvents(bool force); void KillAllEvents(bool force);
void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true); void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
uint64 CalculateTime(uint64 t_offset); uint64 CalculateTime(uint64 t_offset);
protected: protected:
uint64 m_time; uint64 m_time;
EventList m_events; EventList m_events;
bool m_aborting; bool m_aborting;
}; };
#endif #endif

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

@ -27,17 +27,20 @@ class LinkedListHead;
class LinkedListElement class LinkedListElement
{ {
private: private:
friend class LinkedListHead; friend class LinkedListHead;
LinkedListElement* iNext; LinkedListElement* iNext;
LinkedListElement* iPrev; LinkedListElement* iPrev;
public: public:
LinkedListElement() { iNext = NULL; iPrev = NULL; }
LinkedListElement() { iNext = NULL; iPrev = NULL; }
~LinkedListElement() { delink(); } ~LinkedListElement() { delink(); }
bool hasNext() const { return(iNext->iNext != NULL); } bool hasNext() const { return (iNext->iNext != NULL); }
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; }
@ -51,9 +54,12 @@ class LinkedListElement
void delink() void delink()
{ {
if(isInList()) 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 class LinkedListHead
{ {
private: private:
LinkedListElement iFirst; LinkedListElement iFirst;
LinkedListElement iLast; LinkedListElement iLast;
uint32 iSize; uint32 iSize;
public: public:
LinkedListHead() LinkedListHead()
{ {
// create empty list // create empty list
@ -92,13 +101,13 @@ class LinkedListHead
iSize = 0; iSize = 0;
} }
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)
{ {
@ -112,15 +121,17 @@ class LinkedListHead
uint32 getSize() const uint32 getSize() const
{ {
if(!iSize) if (!iSize)
{ {
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();
} }
return result; return result;
} }
else else
@ -131,24 +142,27 @@ class LinkedListHead
void decSize() { --iSize; } void decSize() { --iSize; }
template<class _Ty> template<class _Ty>
class Iterator class Iterator
{ {
public: public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef _Ty value_type; typedef std::bidirectional_iterator_tag iterator_category;
typedef ptrdiff_t difference_type; typedef _Ty value_type;
typedef ptrdiff_t distance_type; typedef ptrdiff_t difference_type;
typedef _Ty* pointer; typedef ptrdiff_t distance_type;
typedef _Ty const* const_pointer; typedef _Ty* pointer;
typedef _Ty& reference; typedef _Ty const* const_pointer;
typedef _Ty const & const_reference; typedef _Ty& reference;
typedef _Ty const& const_reference;
Iterator() : _Ptr(0) Iterator()
: _Ptr(0)
{ // construct with null node pointer { // construct with null node pointer
} }
Iterator(pointer _Pnode) : _Ptr(_Pnode) Iterator(pointer _Pnode)
: _Ptr(_Pnode)
{ // construct with node pointer _Pnode { // construct with node pointer _Pnode
} }
@ -229,13 +243,13 @@ class LinkedListHead
return (_Ptr != &_Right); return (_Ptr != &_Right);
} }
pointer _Mynode() pointer _Mynode()
{ // return node pointer { // return node pointer
return (_Ptr); return (_Ptr);
} }
protected: protected:
pointer _Ptr; // pointer to node pointer _Ptr; // pointer to node
}; };
@ -243,4 +257,5 @@ class LinkedListHead
}; };
//============================================ //============================================
#endif #endif

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

@ -18,21 +18,24 @@
#ifndef _REFMANAGER_H #ifndef _REFMANAGER_H
#define _REFMANAGER_H #define _REFMANAGER_H
//===================================================== //=====================================================
#include "Utilities/LinkedList.h" #include "Utilities/LinkedList.h"
#include "Utilities/LinkedReference/Reference.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: public:
typedef LinkedListHead::Iterator< Reference<TO, FROM> > iterator;
RefManager() { } typedef LinkedListHead::Iterator<Reference<TO, FROM> > iterator;
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()); }
@ -43,7 +46,7 @@ template <class TO, class FROM> class RefManager : public LinkedListHead
void clearReferences() void clearReferences()
{ {
LinkedListElement* ref; LinkedListElement* ref;
while((ref = getFirst()) != NULL) while ((ref = getFirst()) != NULL)
{ {
((Reference<TO, FROM>*) ref)->invalidate(); ((Reference<TO, FROM>*) ref)->invalidate();
ref->delink(); // the delink might be already done by invalidate(), but doing it here again does not hurt and insures an empty list ref->delink(); // the delink might be already done by invalidate(), but doing it here again does not hurt and insures an empty list
@ -52,4 +55,5 @@ template <class TO, class FROM> class RefManager : public LinkedListHead
}; };
//===================================================== //=====================================================
#endif #endif

52
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: private:
TO* iRefTo; TO* iRefTo;
FROM* iRefFrom; FROM* iRefFrom;
protected: protected:
// Tell our refTo (target) object that we have a link // Tell our refTo (target) object that we have a link
virtual void targetObjectBuildLink() = 0; virtual void targetObjectBuildLink() = 0;
@ -37,17 +41,24 @@ template <class TO, class FROM> class Reference : public LinkedListElement
// Tell our refFrom (source) object, that the link is cut (Target destroyed) // Tell our refFrom (source) object, that the link is cut (Target destroyed)
virtual void sourceObjectDestroyLink() = 0; virtual void sourceObjectDestroyLink() = 0;
public: public:
Reference() { iRefTo = NULL; iRefFrom = NULL; }
Reference()
: iRefTo(NULL), iRefFrom(NULL)
{
}
virtual ~Reference() {} virtual ~Reference() {}
// Create new link // Create new link
void link(TO* toObj, FROM* fromObj) void link(TO* toObj, FROM* fromObj)
{ {
assert(fromObj); // fromObj MUST not be NULL ASSERT(fromObj); // fromObj MUST not be NULL
if(isValid()) if (isValid())
unlink(); unlink();
if(toObj != NULL)
if (toObj != NULL)
{ {
iRefTo = toObj; iRefTo = toObj;
iRefFrom = fromObj; iRefFrom = fromObj;
@ -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 // We don't need the reference anymore. Call comes from the refFrom object
// Tell our refTo object, that the link is cut // 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 // 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 // Tell our refFrom object, that the link is cut
void invalidate() // the iRefFrom MUST remain!! void invalidate() // the iRefFrom MUST remain!!
{ {
sourceObjectDestroyLink(); delink(); iRefTo = NULL; sourceObjectDestroyLink();
delink();
iRefTo = NULL;
} }
bool isValid() const // Only check the iRefTo bool isValid() const // Only check the iRefTo
@ -71,21 +90,22 @@ template <class TO, class FROM> 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; }
TO* getTarget() const { return iRefTo; } TO* getTarget() const { return iRefTo; }
FROM* getSource() const { return iRefFrom; } FROM* getSource() const { return iRefFrom; }
}; };
//===================================================== //=====================================================
#endif #endif

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

@ -35,9 +35,10 @@ struct TypeList
}; };
// enough for now.. can be expand at any point in time as needed // enough for now.. can be expand at any point in time as needed
#define TYPELIST_1(T1) TypeList<T1,TypeNull> #define TYPELIST_1(T1) TypeList<T1, TypeNull>
#define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2) > #define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2) >
#define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3) > #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_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) > #define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TYPELIST_4(T2, T3, T4, T5) >
#endif #endif

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

@ -52,11 +52,14 @@ using std::hash_map;
namespace __gnu_cxx 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; } 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; } 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__ #ifndef __REVISION_NR_H__
#define __REVISION_NR_H__ #define __REVISION_NR_H__
#define REVISION_NR "9774" #define REVISION_NR "9775"
#endif // __REVISION_NR_H__ #endif // __REVISION_NR_H__