HashMapHolder< T > Class Template Reference

#include "ObjectAccessor.h"

Public Types
typedef std::unordered_map< ObjectGuid, T * >	MapType

Static Public Member Functions
static void	Insert (T *o)
static void	Remove (T *o)
static T *	Find (ObjectGuid guid)
static MapType &	GetContainer ()
static std::shared_mutex *	GetLock ()

Private Member Functions
	HashMapHolder ()=default

Detailed Description

template<class T>
class HashMapHolder< T >

Member Typedef Documentation

MapType

template<class T >

typedef std::unordered_map<ObjectGuid, T*> HashMapHolder< T >::MapType

Constructor & Destructor Documentation

HashMapHolder()

template<class T >

HashMapHolder< T >::HashMapHolder ( )

privatedefault

Member Function Documentation

Find()

template<class T >

T * HashMapHolder< T >::Find ( ObjectGuid  guid )

static

{
    std::shared_lock<std::shared_mutex> lock(*GetLock());
 
    typename MapType::iterator itr = GetContainer().find(guid);
    return (itr != GetContainer().end()) ? itr->second : nullptr;
}

Referenced by ObjectAccessor::FindConnectedPlayer(), ObjectAccessor::FindPlayer(), WorldSession::HandleRequestPartyMemberStatsOpcode(), Player::LoadFromDB(), Player::Satisfy(), and Map::ScriptsProcess().

GetContainer()

template<class T >

auto HashMapHolder< T >::GetContainer

static

{
    static MapType _objectMap;
    return _objectMap;
}

Referenced by ObjectAccessor::GetPlayers().

GetLock()

template<class T >

std::shared_mutex * HashMapHolder< T >::GetLock

static

{
    static std::shared_mutex _lock;
    return &_lock;
}

Insert()

template<class T >

void HashMapHolder< T >::Insert ( T *  o )

static

{
    static_assert(std::is_same<Player, T>::value
        || std::is_same<MotionTransport, T>::value,
        "Only Player and Motion Transport can be registered in global HashMapHolder");
 
    std::unique_lock<std::shared_mutex> lock(*GetLock());
 
    GetContainer()[o->GetGUID()] = o;
}

Referenced by ObjectAccessor::AddObject(), and TransportMgr::CreateTransport().

Remove()

template<class T >

void HashMapHolder< T >::Remove ( T *  o )

static

{
    std::unique_lock<std::shared_mutex> lock(*GetLock());
 
    GetContainer().erase(o->GetGUID());
}

Referenced by ObjectAccessor::RemoveObject().