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

#include <NekManager.hpp>

Collaboration diagram for Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >:

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

Public Member Functions
	BOOST_CLASS_REQUIRE (KeyType, boost, LessThanComparableConcept)
	NekManager (std::string whichPool="")
	NekManager (CreateFuncType f, std::string whichPool="")
	~NekManager ()
bool	RegisterCreator (typename boost::call_traits< KeyType >::const_reference 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...
bool	AlreadyCreated (typename boost::call_traits< KeyType >::const_reference key)
ValueType	operator[] (typename boost::call_traits< KeyType >::const_reference key)
void	DeleteObject (typename boost::call_traits< KeyType >::const_reference key)

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
static boost::shared_mutex	m_mutex

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

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

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

Definition at line 80 of file NekManager.hpp.

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 78 of file NekManager.hpp.

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

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

Definition at line 75 of file NekManager.hpp.

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.

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

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

Definition at line 76 of file NekManager.hpp.

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

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

Definition at line 79 of file NekManager.hpp.

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

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

Definition at line 77 of file NekManager.hpp.

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

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

Definition at line 74 of file NekManager.hpp.

Constructor & Destructor Documentation

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())
                    {
                        typename ValueContainerPool::iterator 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));
                    }
                };

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())
                    {
                        ReadLock v_rlock(m_mutex); // reading static members
                        typename ValueContainerPool::iterator iter = m_ValueContainerPool.find(whichPool);
                        if (iter != m_ValueContainerPool.end())
                        {
                            m_values = iter->second;
                            m_managementEnabled = m_managementEnabledContainerPool[whichPool];
                        }
                        else
                        {
                            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);
                            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));
                    }
                }

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

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

inline

Definition at line 155 of file NekManager.hpp.

                {
                }

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

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

bool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::AlreadyCreated ( typename boost::call_traits< KeyType >::const_reference  key )

inline

Definition at line 178 of file NekManager.hpp.

                {
                    bool value = false;
                    typename ValueContainer::iterator found = m_values->find(key);
                    if( found != m_values->end() )
                    {
                        value = true;
                    }

                    return value;
                }

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

Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::BOOST_CLASS_REQUIRE	(	KeyType	,
		boost	,
		LessThanComparableConcept
	)

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 238 of file NekManager.hpp.

                {
                    typename ValueContainerPool::iterator x;
                    if (!whichPool.empty())
                    {
                        WriteLock v_wlock(m_mutex);

                        x = m_ValueContainerPool.find(whichPool);
                        ASSERTL1(x != m_ValueContainerPool.end(),
                                "Could not find pool " + whichPool);
                        x->second->clear();
                    }
                    else
                    {
                        WriteLock v_wlock(m_mutex);

                        for (x = m_ValueContainerPool.begin(); x != m_ValueContainerPool.end(); ++x)
                        {
                            x->second->clear();
                        }
                    }
                }

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

void Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::DeleteObject ( typename boost::call_traits< KeyType >::const_reference  key )

inline

Definition at line 228 of file NekManager.hpp.

                {
                    typename ValueContainer::iterator found = m_values->find(key);

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

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 293 of file NekManager.hpp.

Referenced by Nektar::VortexWaveInteraction::ExecuteLoop().

                {
                    typename FlagContainerPool::iterator x;
                    if (!whichPool.empty())
                    {
                        WriteLock v_wlock(m_mutex);

                        x = m_managementEnabledContainerPool.find(whichPool);
                        if (x != m_managementEnabledContainerPool.end())
                        {
                            (*x->second) = false;
                        }
                        else
                        {
                            m_managementEnabledContainerPool[whichPool] = BoolSharedPtr(new bool(false));
                        }
                    }
                }

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 274 of file NekManager.hpp.

Referenced by Nektar::VortexWaveInteraction::ExecuteLoop().

                {
                    typename FlagContainerPool::iterator x;
                    if (!whichPool.empty())
                    {
                        WriteLock v_wlock(m_mutex);

                        x = m_managementEnabledContainerPool.find(whichPool);
                        if (x != m_managementEnabledContainerPool.end())
                        {
                            (*x->second) = true;
                        }
                        else
                        {
                            m_managementEnabledContainerPool[whichPool] = BoolSharedPtr(new bool(true));
                        }
                    }
                }

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

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

ValueType Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::operator[] ( typename boost::call_traits< KeyType >::const_reference  key )

inline

Definition at line 190 of file NekManager.hpp.

                {
                    typename ValueContainer::iterator found = m_values->find(key);

                    if( found != m_values->end() )
                    {
                        return (*found).second;
                    }
                    else
                    {
                        // No object, create a new one.
                        CreateFuncType f = m_globalCreateFunc;
                        typename CreateFuncContainer::iterator keyFound = m_keySpecificCreateFuncs.find(key);
                        if( keyFound != m_keySpecificCreateFuncs.end() )
                        {
                            f = (*keyFound).second;
                        }

                        if( f )
                        {
                            ValueType v = f(key);
                            if (*m_managementEnabled)
                            {
                                (*m_values)[key] = v;
                            }
                            return v;
                        }
                        else
                        {
                            std::string keyAsString = boost::lexical_cast<std::string>(key);
                            std::string message = std::string("No create func found for key ") + keyAsString;
                            NEKERROR(ErrorUtil::efatal, message.c_str());
                            static ValueType result;
                            return result;
                        }
                    }
                }

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 261 of file NekManager.hpp.

                {
                    bool value = false;
                    typename ValueContainerPool::iterator x;

                    x = m_ValueContainerPool.find(whichPool);
                    if (x != m_ValueContainerPool.end())
                    {
                        value = true;
                    }
                    return value;
                }

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

bool Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterCreator ( typename boost::call_traits< KeyType >::const_reference  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 161 of file NekManager.hpp.

                {
                    m_keySpecificCreateFuncs[key] = createFunc;

                    return true;
                }

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 171 of file NekManager.hpp.

Referenced by Nektar::LibUtilities::TimeIntegrationSchemeManager().

                {
                    m_globalCreateFunc = createFunc;

                    return true;
                }

Member Data Documentation

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

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

private

Definition at line 320 of file NekManager.hpp.

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

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

private

Definition at line 321 of file NekManager.hpp.

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

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

private

Definition at line 317 of file NekManager.hpp.

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

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

staticprivate

Definition at line 319 of file NekManager.hpp.

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

boost::shared_mutex Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::m_mutex

staticprivate

Definition at line 322 of file NekManager.hpp.

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

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

staticprivate

Definition at line 318 of file NekManager.hpp.

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

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

private

Definition at line 316 of file NekManager.hpp.