Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator > Class Template Reference

#include <NekManager.hpp>

Public Types
typedef std::shared_ptr< ValueT >	ValueType
typedef std::function< ValueType(const KeyType &key)>	CreateFuncType
typedef std::map< KeyType, ValueType >	ValueContainer
typedef std::shared_ptr< ValueContainer >	ValueContainerShPtr
typedef std::map< KeyType, CreateFuncType, opLessCreator >	CreateFuncContainer
typedef std::map< std::string, std::shared_ptr< ValueContainer > >	ValueContainerPool
typedef std::shared_ptr< bool >	BoolSharedPtr
typedef std::map< std::string, BoolSharedPtr >	FlagContainerPool

Public Member Functions
	NekManager (std::string whichPool="")
	NekManager (CreateFuncType f, std::string whichPool="")
	~NekManager ()
bool	RegisterCreator (const KeyType &key, const CreateFuncType &createFunc)
	Register the given function and associate it with the key. The return value is just to facilitate calling statically. More...
bool	RegisterGlobalCreator (const CreateFuncType &createFunc)
	Register the Global Create Function. The return value is just to facilitate calling statically. More...
ValueType	operator[] (const KeyType &key)
void	DeleteObject (const KeyType &key)
size_t	PoolCount (std::string whichPool)

Static Public Member Functions
static void	ClearManager (std::string whichPool="")
static bool	PoolCreated (std::string whichPool)
static void	EnableManagement (std::string whichPool="")
static void	DisableManagement (std::string whichPool="")

Private Member Functions
NekManager< KeyType, ValueType, opLessCreator > &	operator= (const NekManager< KeyType, ValueType, opLessCreator > &rhs)
	NekManager (const NekManager< KeyType, ValueType, opLessCreator > &rhs)

Private Attributes
ValueContainerShPtr	m_values
BoolSharedPtr	m_managementEnabled
CreateFuncType	m_globalCreateFunc
CreateFuncContainer	m_keySpecificCreateFuncs

Static Private Attributes
static ValueContainerPool	m_ValueContainerPool
static FlagContainerPool	m_managementEnabledContainerPool

Detailed Description

template<typename KeyType, typename ValueT, typename opLessCreator = defOpLessCreator<KeyType>>
class Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >

Definition at line 69 of file NekManager.hpp.

Member Typedef Documentation

BoolSharedPtr

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::shared_ptr<bool> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::BoolSharedPtr

Definition at line 80 of file NekManager.hpp.

CreateFuncContainer

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::map<KeyType, CreateFuncType, opLessCreator> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::CreateFuncContainer

Definition at line 77 of file NekManager.hpp.

CreateFuncType

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::function<ValueType(const KeyType &key)> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::CreateFuncType

Definition at line 73 of file NekManager.hpp.

FlagContainerPool

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::map<std::string, BoolSharedPtr> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::FlagContainerPool

Definition at line 81 of file NekManager.hpp.

ValueContainer

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::map<KeyType, ValueType> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ValueContainer

Definition at line 74 of file NekManager.hpp.

ValueContainerPool

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::map<std::string, std::shared_ptr<ValueContainer> > Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ValueContainerPool

Definition at line 79 of file NekManager.hpp.

ValueContainerShPtr

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::shared_ptr<ValueContainer> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ValueContainerShPtr

Definition at line 75 of file NekManager.hpp.

ValueType

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

typedef std::shared_ptr<ValueT> Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ValueType

Definition at line 72 of file NekManager.hpp.

Constructor & Destructor Documentation

NekManager() [1/3]

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager ( std::string  whichPool = "" )

inline

Definition at line 83 of file NekManager.hpp.

        : m_values(), m_globalCreateFunc(), m_keySpecificCreateFuncs()
    {
        if (!whichPool.empty())
        {
            auto iter = m_ValueContainerPool.find(whichPool);
            if (iter != m_ValueContainerPool.end())
            {
                m_values = iter->second;
                m_managementEnabled =
                    m_managementEnabledContainerPool[whichPool];
            }
            else
            {
                m_values = ValueContainerShPtr(new ValueContainer);
                m_ValueContainerPool[whichPool] = m_values;
                if (m_managementEnabledContainerPool.find(whichPool) ==
                    m_managementEnabledContainerPool.end())
                {
                    m_managementEnabledContainerPool[whichPool] =
                        BoolSharedPtr(new bool(true));
                }
                m_managementEnabled =
                    m_managementEnabledContainerPool[whichPool];
            }
        }
        else
        {
            m_values            = ValueContainerShPtr(new ValueContainer);
            m_managementEnabled = BoolSharedPtr(new bool(true));
        }
    };

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabled, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabledContainerPool, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool, and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_values.

NekManager() [2/3]

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager ( CreateFuncType  f, std::string  whichPool = ""  )

inlineexplicit

Definition at line 116 of file NekManager.hpp.

        : m_values(), m_globalCreateFunc(f), m_keySpecificCreateFuncs()
    {
        if (!whichPool.empty())
        {
#ifdef NEKTAR_USE_THREAD_SAFETY
            ReadLock v_rlock(m_mutex); // reading static members
#endif
            auto iter = m_ValueContainerPool.find(whichPool);
            if (iter != m_ValueContainerPool.end())
            {
                m_values = iter->second;
                m_managementEnabled =
                    m_managementEnabledContainerPool[whichPool];
            }
            else
            {
#ifdef NEKTAR_USE_THREAD_SAFETY
                v_rlock.unlock();
                // Now writing static members.  Apparently
                // upgrade_lock has less desirable properties than
                // just dropping read lock, grabbing write lock.
                // write will block until all reads are done, but
                // reads cannot be acquired if write lock is
                // blocking.  In this context writes are supposed to
                // be rare.
                WriteLock v_wlock(m_mutex);
#endif
                m_values = ValueContainerShPtr(new ValueContainer);
                m_ValueContainerPool[whichPool] = m_values;
                if (m_managementEnabledContainerPool.find(whichPool) ==
                    m_managementEnabledContainerPool.end())
                {
                    m_managementEnabledContainerPool[whichPool] =
                        BoolSharedPtr(new bool(true));
                }
                m_managementEnabled =
                    m_managementEnabledContainerPool[whichPool];
            }
        }
        else
        {
            m_values            = ValueContainerShPtr(new ValueContainer);
            m_managementEnabled = BoolSharedPtr(new bool(true));
        }
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabled, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabledContainerPool, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool, and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_values.

~NekManager()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::~NekManager ( )

inline

Definition at line 163 of file NekManager.hpp.

    {
    }

NekManager() [3/3]

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager ( const NekManager< KeyType, ValueType, opLessCreator > &  rhs )

private

Member Function Documentation

ClearManager()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

static void Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ClearManager ( std::string  whichPool = "" )

inlinestatic

Definition at line 233 of file NekManager.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        WriteLock v_wlock(m_mutex);
#endif
 
        if (!whichPool.empty())
        {
            auto x = m_ValueContainerPool.find(whichPool);
            ASSERTL1(x != m_ValueContainerPool.end(),
                     "Could not find pool " + whichPool);
            x->second->clear();
        }
        else
        {
            for (auto &x : m_ValueContainerPool)
            {
                x.second->clear();
            }
        }
    }

References ASSERTL1, and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool.

DeleteObject()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

void Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::DeleteObject ( const KeyType &  key )

inline

Definition at line 223 of file NekManager.hpp.

    {
        auto found = m_values->find(key);
 
        if (found != m_values->end())
        {
            m_values->erase(found);
        }
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_values.

DisableManagement()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

static void Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::DisableManagement ( std::string  whichPool = "" )

inlinestatic

Definition at line 290 of file NekManager.hpp.

    {
        if (!whichPool.empty())
        {
#ifdef NEKTAR_USE_THREAD_SAFETY
            WriteLock v_wlock(m_mutex);
#endif
            auto x = m_managementEnabledContainerPool.find(whichPool);
            if (x != m_managementEnabledContainerPool.end())
            {
                (*x->second) = false;
            }
            else
            {
                m_managementEnabledContainerPool[whichPool] =
                    BoolSharedPtr(new bool(false));
            }
        }
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabledContainerPool.

EnableManagement()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

static void Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::EnableManagement ( std::string  whichPool = "" )

inlinestatic

Definition at line 269 of file NekManager.hpp.

    {
        if (!whichPool.empty())
        {
#ifdef NEKTAR_USE_THREAD_SAFETY
            WriteLock v_wlock(m_mutex);
#endif
 
            auto x = m_managementEnabledContainerPool.find(whichPool);
            if (x != m_managementEnabledContainerPool.end())
            {
                (*x->second) = true;
            }
            else
            {
                m_managementEnabledContainerPool[whichPool] =
                    BoolSharedPtr(new bool(true));
            }
        }
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabledContainerPool.

operator=()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

NekManager< KeyType, ValueType, opLessCreator > & Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator= ( const NekManager< KeyType, ValueType, opLessCreator > &  rhs )

private

operator[]()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

ValueType Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[] ( const KeyType &  key )

inline

Definition at line 185 of file NekManager.hpp.

    {
        auto found = m_values->find(key);
 
        if (found != m_values->end())
        {
            return (*found).second;
        }
        else
        {
            // No object, create a new one.
            auto keyFound = m_keySpecificCreateFuncs.find(key);
            bool isfound  = keyFound != m_keySpecificCreateFuncs.end();
            CreateFuncType f =
                isfound ? (*keyFound).second : m_globalCreateFunc;
 
            if (f)
            {
                ValueType v = f(key);
                if (*m_managementEnabled)
                {
                    (*m_values)[key] = v;
                }
                return v;
            }
            else
            {
                std::stringstream ss;
                ss << key;
                std::string message =
                    "No create func found for key " + ss.str();
                NEKERROR(ErrorUtil::efatal, message.c_str());
                static ValueType result;
                return result;
            }
        }
    }

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_globalCreateFunc, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_keySpecificCreateFuncs, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabled, Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_values, and NEKERROR.

PoolCount()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

size_t Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::PoolCount ( std::string  whichPool )

inline

Definition at line 261 of file NekManager.hpp.

    {
        auto x = m_ValueContainerPool.find(whichPool);
        ASSERTL1(x != m_ValueContainerPool.end(),
                 "Could not find pool " + whichPool);
        return x->second->size();
    }

References ASSERTL1, and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool.

PoolCreated()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

static bool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::PoolCreated ( std::string  whichPool )

inlinestatic

Definition at line 255 of file NekManager.hpp.

    {
        return m_ValueContainerPool.find(whichPool) !=
               m_ValueContainerPool.end();
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool.

RegisterCreator()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

bool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterCreator ( const KeyType &  key, const CreateFuncType &  createFunc  )

inline

Register the given function and associate it with the key. The return value is just to facilitate calling statically.

Definition at line 169 of file NekManager.hpp.

    {
        m_keySpecificCreateFuncs[key] = createFunc;
 
        return true;
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_keySpecificCreateFuncs.

RegisterGlobalCreator()

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

bool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterGlobalCreator ( const CreateFuncType &  createFunc )

inline

Register the Global Create Function. The return value is just to facilitate calling statically.

Definition at line 178 of file NekManager.hpp.

    {
        m_globalCreateFunc = createFunc;
 
        return true;
    }

References Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_globalCreateFunc.

Member Data Documentation

m_globalCreateFunc

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

CreateFuncType Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_globalCreateFunc

private

Definition at line 319 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[](), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterGlobalCreator().

m_keySpecificCreateFuncs

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

CreateFuncContainer Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_keySpecificCreateFuncs

private

Definition at line 320 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[](), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterCreator().

m_managementEnabled

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

BoolSharedPtr Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabled

private

Definition at line 316 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager(), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[]().

m_managementEnabledContainerPool

template<typename KeyType , typename ValueT , typename opLessCreator >

NekManager< KeyType, ValueT, opLessCreator >::FlagContainerPool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_managementEnabledContainerPool

staticprivate

Definition at line 318 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::DisableManagement(), Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::EnableManagement(), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager().

m_ValueContainerPool

template<typename KeyType , typename ValueT , typename opLessCreator >

NekManager< KeyType, ValueT, opLessCreator >::ValueContainerPool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_ValueContainerPool

staticprivate

Definition at line 317 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::ClearManager(), Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager(), Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::PoolCount(), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::PoolCreated().

m_values

template<typename KeyType , typename ValueT , typename opLessCreator = defOpLessCreator<KeyType>>

ValueContainerShPtr Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_values

private

Definition at line 315 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::DeleteObject(), Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::NekManager(), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[]().