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

Various Cleanups (framework/)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -24,7 +24,7 @@
void* operator new(size_t sz)
{
void *res = scalable_malloc(sz);
void* res = scalable_malloc(sz);
if (res == NULL)
throw std::bad_alloc();
@ -34,7 +34,7 @@ void* operator new(size_t sz)
void* operator new[](size_t sz)
{
void *res = scalable_malloc(sz);
void* res = scalable_malloc(sz);
if (res == NULL)
throw std::bad_alloc();

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

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

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

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

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

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

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

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

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

@ -29,19 +29,19 @@
namespace ByteConverter
{
template<size_t T>
inline void convert(char *val)
inline void convert(char* val)
{
std::swap(*val, *(val + T - 1));
convert<T - 2>(val + 1);
}
template<> inline void convert<0>(char *) {}
template<> inline void convert<1>(char *) {} // ignore central byte
template<> inline void convert<0>(char*) {}
template<> inline void convert<1>(char*) {} // ignore central byte
template<typename T>
inline void apply(T *val)
inline void apply(T* val)
{
convert<sizeof(T)>((char *)(val));
convert<sizeof(T)>((char*)(val));
}
}
@ -59,6 +59,6 @@ template<typename T> void EndianConvertReverse(T*); // will generate link error
inline void EndianConvert(uint8&) { }
inline void EndianConvert(int8&) { }
inline void EndianConvertReverse(uint8&) { }
inline void EndianConvertReverse( int8&) { }
inline void EndianConvertReverse(int8&) { }
#endif

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

@ -54,7 +54,7 @@ namespace MaNGOS
protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
Class *m_object;
Class* m_object;
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
@ -64,15 +64,15 @@ namespace MaNGOS
public:
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
_Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
: m_object(object), m_method(method),
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
{
}
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
: m_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
{
}
};
@ -83,7 +83,7 @@ namespace MaNGOS
protected:
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
Class *m_object;
Class* m_object;
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
@ -91,15 +91,15 @@ namespace MaNGOS
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
public:
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
_Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_object(object), m_method(method),
m_param1(param1), m_param2(param2), m_param3(param3)
m_param1(param1), m_param2(param2), m_param3(param3)
{
}
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3> const& cb)
: m_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
{
}
};
@ -110,7 +110,7 @@ namespace MaNGOS
protected:
typedef void (Class::*Method)(ParamType1, ParamType2);
Class *m_object;
Class* m_object;
Method m_method;
ParamType1 m_param1;
ParamType2 m_param2;
@ -118,15 +118,15 @@ namespace MaNGOS
public:
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2)
_Callback(Class* object, Method method, ParamType1 param1, ParamType2 param2)
: m_object(object), m_method(method),
m_param1(param1), m_param2(param2)
m_param1(param1), m_param2(param2)
{
}
_Callback(_Callback<Class, ParamType1, ParamType2> const& cb)
: m_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2)
m_param1(cb.m_param1), m_param2(cb.m_param2)
{
}
};
@ -137,22 +137,22 @@ namespace MaNGOS
protected:
typedef void (Class::*Method)(ParamType1);
Class *m_object;
Class* m_object;
Method m_method;
ParamType1 m_param1;
void _Execute() { (m_object->*m_method)(m_param1); }
public:
_Callback(Class *object, Method method, ParamType1 param1)
_Callback(Class* object, Method method, ParamType1 param1)
: m_object(object), m_method(method),
m_param1(param1)
m_param1(param1)
{
}
_Callback(_Callback<Class, ParamType1> const& cb)
: m_object(cb.m_object), m_method(cb.m_method),
m_param1(cb.m_param1)
m_param1(cb.m_param1)
{
}
};
@ -163,12 +163,12 @@ namespace MaNGOS
protected:
typedef void (Class::*Method)();
Class *m_object;
Class* m_object;
Method m_method;
void _Execute() { (m_object->*m_method)(); }
public:
_Callback(Class *object, Method method)
_Callback(Class* object, Method method)
: m_object(object), m_method(method)
{
}
@ -197,13 +197,13 @@ namespace MaNGOS
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
: m_method(method),
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
{
}
_SCallback(_SCallback<ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4)
{
}
};
@ -223,12 +223,12 @@ namespace MaNGOS
public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: m_method(method),
m_param1(param1), m_param2(param2), m_param3(param3)
m_param1(param1), m_param2(param2), m_param3(param3)
{
}
_SCallback(_SCallback<ParamType1, ParamType2, ParamType3> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
{
}
};
@ -247,13 +247,13 @@ namespace MaNGOS
public:
_SCallback(Method method, ParamType1 param1, ParamType2 param2)
: m_method(method),
m_param1(param1), m_param2(param2)
m_param1(param1), m_param2(param2)
{
}
_SCallback(_SCallback<ParamType1, ParamType2> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1), m_param2(cb.m_param2)
m_param1(cb.m_param1), m_param2(cb.m_param2)
{
}
};
@ -271,13 +271,13 @@ namespace MaNGOS
public:
_SCallback(Method method, ParamType1 param1)
: m_method(method),
m_param1(param1)
m_param1(param1)
{
}
_SCallback(_SCallback<ParamType1> const& cb)
: m_method(cb.m_method),
m_param1(cb.m_param1)
m_param1(cb.m_param1)
{
}
};
@ -337,7 +337,7 @@ namespace MaNGOS
typedef _Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> C4;
public:
Callback(Class *object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
Callback(Class* object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
: _ICallback<C4>(C4(object, method, param1, param2, param3, param4))
{
}
@ -351,7 +351,7 @@ namespace MaNGOS
typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3;
public:
Callback(Class *object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
Callback(Class* object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: _ICallback<C3>(C3(object, method, param1, param2, param3))
{
}
@ -365,7 +365,7 @@ namespace MaNGOS
typedef _Callback<Class, ParamType1, ParamType2> C2;
public:
Callback(Class *object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
Callback(Class* object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
: _ICallback<C2>(C2(object, method, param1, param2))
{
}
@ -380,7 +380,7 @@ namespace MaNGOS
public:
Callback(Class *object, typename C1::Method method, ParamType1 param1)
Callback(Class* object, typename C1::Method method, ParamType1 param1)
: _ICallback<C1>(C1(object, method, param1))
{
}
@ -395,7 +395,7 @@ namespace MaNGOS
public:
Callback(Class *object, typename C0::Method method)
Callback(Class* object, typename C0::Method method)
: _ICallback<C0>(C0(object, method))
{
}
@ -441,7 +441,7 @@ namespace MaNGOS
public:
QueryCallback(Class *object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
QueryCallback(Class* object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
: _IQueryCallback<QC3>(QC3(object, method, result, param1, param2, param3))
{
}
@ -456,7 +456,7 @@ namespace MaNGOS
public:
QueryCallback(Class *object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
QueryCallback(Class* object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
: _IQueryCallback<QC2>(QC2(object, method, result, param1, param2))
{
}
@ -471,7 +471,7 @@ namespace MaNGOS
public:
QueryCallback(Class *object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
QueryCallback(Class* object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
: _IQueryCallback<QC1>(QC1(object, method, result, param1))
{
}
@ -485,7 +485,7 @@ namespace MaNGOS
typedef _Callback<Class, QueryResult*> QC0;
public:
QueryCallback(Class *object, typename QC0::Method method, QueryResult* result)
QueryCallback(Class* object, typename QC0::Method method, QueryResult* result)
: _IQueryCallback<QC0>(QC0(object, method, result))
{
}

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

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

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

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

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

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

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

@ -90,14 +90,14 @@ class Reference : public LinkedListElement
return iRefTo != NULL;
}
Reference<TO,FROM> * next() { return((Reference<TO, FROM> *) LinkedListElement::next()); }
Reference<TO,FROM>* next() { return((Reference<TO, FROM>*) LinkedListElement::next()); }
Reference<TO,FROM> const* next() const { return((Reference<TO, FROM> const*) LinkedListElement::next()); }
Reference<TO,FROM> * prev() { return((Reference<TO, FROM> *) LinkedListElement::prev()); }
Reference<TO,FROM>* prev() { return((Reference<TO, FROM>*) LinkedListElement::prev()); }
Reference<TO,FROM> const* prev() const { return((Reference<TO, FROM> const*) LinkedListElement::prev()); }
Reference<TO,FROM> * nocheck_next() { return((Reference<TO, FROM> *) LinkedListElement::nocheck_next()); }
Reference<TO,FROM>* nocheck_next() { return((Reference<TO, FROM>*) LinkedListElement::nocheck_next()); }
Reference<TO,FROM> const* nocheck_next() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_next()); }
Reference<TO,FROM> * nocheck_prev() { return((Reference<TO, FROM> *) LinkedListElement::nocheck_prev()); }
Reference<TO,FROM>* nocheck_prev() { return((Reference<TO, FROM>*) LinkedListElement::nocheck_prev()); }
Reference<TO,FROM> const* nocheck_prev() const { return((Reference<TO, FROM> const*) LinkedListElement::nocheck_prev()); }
TO* operator->() const { return iRefTo; }

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

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