KitManager< T_KitInterface > Class Template Reference

#include <KitManager.h>

Inheritance diagram for KitManager< T_KitInterface >:

Collaboration diagram for KitManager< T_KitInterface >:

Public Member Functions
	~KitManager ()
bool	registerKit (const std::string &name, const T_KitInterface *a_kit)
const T_KitInterface &	kit (const std::string &name) const
void	dumpKits (std::ostream &out) const

Static Public Member Functions
static KitManager< T_KitInterface > &	instance ()

Protected Member Functions
const void *	kitPtr (const std::string &name) const
bool	registerKit (const std::string &name, const void *a_kit)

Protected Attributes
std::mutex	m_mutex
std::map< std::string, const void * >	m_registry

Detailed Description

template<class T_KitInterface>
class KitManager< T_KitInterface >

Definition at line 31 of file KitManager.h.

Constructor & Destructor Documentation

~KitManager()

template<class T_KitInterface>

KitManager< T_KitInterface >::~KitManager ( )

inline

Definition at line 33 of file KitManager.h.

                {
    for( std::pair<const std::string, const void *> &elm : m_registry ) {
      const T_KitInterface *ptr=reinterpret_cast<const T_KitInterface *>(elm.second);
      delete ptr;
      elm.second = nullptr;
    }
  }

Member Function Documentation

dumpKits()

void KitManagerBase::dumpKits ( std::ostream & out ) const

inherited

Definition at line 27 of file KitManager.cxx.

                                                   {
  std::lock_guard<std::mutex> lock (m_mutex);
  for(const std::pair<const std::string, const void *> &elm: m_registry) {
    out << " " << elm.first;
  }
}

instance()

template<class T_KitInterface>

KitManager< T_KitInterface > & KitManager< T_KitInterface >::instance ( )

inlinestatic

Definition at line 50 of file KitManager.h.

                                         {
    /* in C++11 this is to happen once the issue is that we return a ref
     * rather than const ref. To be thread safe we need to have static const */
    // Map is protected with a lock.
    static KitManager<T_KitInterface> s_instance ATLAS_THREAD_SAFE;
    return s_instance;
  }

kit()

template<class T_KitInterface>

const T_KitInterface & KitManager< T_KitInterface >::kit ( const std::string & name ) const

inline

Definition at line 45 of file KitManager.h.

                                                         {
    return *(reinterpret_cast< const T_KitInterface *>(KitManagerBase::kitPtr(name)));
  }

kitPtr()

const void * KitManagerBase::kitPtr ( const std::string & name ) const

protectedinherited

Definition at line 11 of file KitManager.cxx.

                                                              {
  std::lock_guard<std::mutex> lock (m_mutex);
  return m_registry.at(name);
}

registerKit() [1/2]

template<class T_KitInterface>

bool KitManager< T_KitInterface >::registerKit ( const std::string & name, const T_KitInterface * a_kit )

inline

Definition at line 41 of file KitManager.h.

                                                                       {
    return KitManagerBase::registerKit(name, static_cast< const void *>(a_kit));
  }

registerKit() [2/2]

bool KitManagerBase::registerKit ( const std::string & name, const void * a_kit )

protectedinherited

Definition at line 16 of file KitManager.cxx.

                                                                         {
  std::lock_guard<std::mutex> lock (m_mutex);
  std::pair<std::string, const void *> elm = std::make_pair(name, a_kit);
  if (!m_registry.insert(elm).second) {
    std::stringstream message;
    message << "Failed to register kit " << elm.first;
    throw std::runtime_error(message.str());
  }
  return true;
}

Member Data Documentation

m_mutex

std::mutex KitManagerBase::m_mutex

mutableprotectedinherited

Definition at line 23 of file KitManager.h.

m_registry

std::map<std::string, const void * > KitManagerBase::m_registry

protectedinherited

Definition at line 24 of file KitManager.h.

---

The documentation for this class was generated from the following file:

• KitManager.h