#include <Store.h>

Public Types
typedef registry_type::const_iterator	const_iterator
typedef registry_type::iterator	iterator
typedef K	key_type
typedef N	name_type
typedef I	pimpl_type
typedef Rep_type *	prep_type
typedef std::map< name_type, prep_type >	registry_type
typedef rep_type< name_type, pimpl_type >	Rep_type
typedef registry_type::size_type	size_type
Public Member Functions
iterator	begin ()
const_iterator	begin () const
void	clear ()
prep_type	create (const name_type &)
prep_type	create (const name_type &, pimpl_type)
const_iterator	end () const
iterator	end ()
bool	isDefined (const name_type &n) const
bool	readOnly () const
void	setReadOnly (bool b)
size_type	size () const
	Store ()
void	swap (Store &)
	~Store ()
Protected Member Functions
Store &	operator= (const Store &)
	Store (const Store &)
Protected Attributes
bool	readOnly_
registry_type	reg_

Detailed Description

template<class N, class I, class K = I>
class DDI::Store< N, I, K >

A Store provides a place for objects of type I which are uniquely identified by there name of type N. The objects themselves can be accessed indirectly by the prep_type of the Store like

typedef Store<std::string,double> NamedDouble; NamedDouble::prep_type d = NamedDouble("Four", new double(4.)); double val = *(d->second); std::string name = d->first;

K is the key_type which is used as an index in the storage. It must fulfill all requirements for a key in a sorted associative container. N is the user-friendly name_type, which must be mapped uniquely to the key_type and vice versa. N itself must also fulfill all requirements of a key in a sorted associative container. The reason to provide K is that one might save some memory by compacting common parts of information contained in different instances of N, e.g. if N is a pair<string,string>, the first string being a 'namespace' the second a 'name' then K could be a pair<int,string> thus compacting the namespace-string to a simple int. K and N must support following unique conversions:

from N to K, thus N(const K &)
from K to N, thus K(const N &)

Definition at line 37 of file Store.h.

Member Typedef Documentation

template<class N, class I, class K = I>

typedef registry_type::const_iterator DDI::Store< N, I, K >::const_iterator

Definition at line 60 of file Store.h.

template<class N, class I, class K = I>

typedef registry_type::iterator DDI::Store< N, I, K >::iterator

Definition at line 59 of file Store.h.

template<class N, class I, class K = I>

typedef K DDI::Store< N, I, K >::key_type

Definition at line 43 of file Store.h.

template<class N, class I, class K = I>

typedef N DDI::Store< N, I, K >::name_type

Definition at line 40 of file Store.h.

template<class N, class I, class K = I>

typedef I DDI::Store< N, I, K >::pimpl_type

Definition at line 41 of file Store.h.

template<class N, class I, class K = I>

typedef Rep_type* DDI::Store< N, I, K >::prep_type

Definition at line 56 of file Store.h.

template<class N, class I, class K = I>

typedef std::map<name_type,prep_type> DDI::Store< N, I, K >::registry_type

Definition at line 58 of file Store.h.

template<class N, class I, class K = I>

typedef rep_type<name_type, pimpl_type> DDI::Store< N, I, K >::Rep_type

Definition at line 44 of file Store.h.

template<class N, class I, class K = I>

typedef registry_type::size_type DDI::Store< N, I, K >::size_type

Definition at line 61 of file Store.h.

Constructor & Destructor Documentation

template<class N, class I, class K = I>

DDI::Store< N, I, K >::Store ( ) [inline]

Definition at line 88 of file Store.h.

: readOnly_(false) { }

template<class N , class I , class K >

DDI::Store< N, I, K >::~Store ( )

Definition at line 157 of file Store.h.

 {
   typename registry_type::iterator it = reg_.begin();
   for(; it != reg_.end(); ++it) {
//     std::cout << "deleting " << it->first << std::endl;
     delete it->second->second; it->second->second = 0;
     delete it->second; it->second = 0;
   }
 }

template<class N, class I, class K = I>

DDI::Store< N, I, K >::Store ( const Store< N, I, K > & ) [protected]

Member Function Documentation

template<class N, class I, class K = I>

iterator DDI::Store< N, I, K >::begin ( void ) [inline]

Definition at line 63 of file Store.h.

{ return reg_.begin(); }

template<class N, class I, class K = I>

const_iterator DDI::Store< N, I, K >::begin ( void ) const [inline]

Definition at line 64 of file Store.h.

{ return reg_.begin(); }

template<class N, class I, class K = I>

void DDI::Store< N, I, K >::clear ( )

template<class N , class I , class K >

Store< N, I, K >::prep_type DDI::Store< N, I, K >::create ( const name_type & n )

Definition at line 121 of file Store.h.

References Exception, Exhume::I, query::result, and tmp.

 {
   prep_type tmp = 0;
   std::pair<typename registry_type::iterator,bool> result 
     = reg_.insert(std::make_pair(n,tmp));
   if (result.second) {
     if (readOnly_) throw cms::Exception("DetectorDescriptionStore")<<" Store has been locked.  Illegal attempt to add " << n << " to a global store."; 
     // ELSE     
     result.first->second = new Rep_type(n,(I)0);
   }
   return result.first->second;    
 }

template<class N , class I , class K >

Store< N, I, K >::prep_type DDI::Store< N, I, K >::create	(	const name_type &	n,
		pimpl_type	p
	)

Definition at line 137 of file Store.h.

References Exception, L1TEmulatorMonitor_cff::p, query::result, and tmp.

 {                      
   if (readOnly_) throw cms::Exception("DetectorDescriptionStore")<<" Store has been locked.  Illegal attempt to add " << n << " to a global store."; 
   // ELSE     
   prep_type tmp = 0;
   std::pair<typename registry_type::iterator,bool> result 
     = reg_.insert(std::make_pair(n,tmp));
   if (!result.second) {
     delete result.first->second->second;
     result.first->second->second = p;
     //delete result.first->second->swap(p);
   }
   else {
     result.first->second = new Rep_type(n,p);
   }
   return result.first->second;
 }

template<class N, class I, class K = I>

const_iterator DDI::Store< N, I, K >::end ( void ) const [inline]

Definition at line 66 of file Store.h.

{ return reg_.end(); }

template<class N, class I, class K = I>

iterator DDI::Store< N, I, K >::end ( void ) [inline]

Definition at line 65 of file Store.h.

{ return reg_.end(); }

template<class N , class I , class K >

bool DDI::Store< N, I, K >::isDefined ( const name_type & n ) const

Definition at line 176 of file Store.h.

References query::result.

{
  if (readOnly_) edm::LogWarning("DetectorDescriptionStore") << " Store is locked and most likely empty.  isDefined will be false.";
  typename registry_type::const_iterator it = reg_.find(n);
  bool result(false);
  if (it != reg_.end()) {
    if (it->second->second) {
      result=true;
    }  
  }
  return result;
}

template<class N, class I, class K = I>

Store& DDI::Store< N, I, K >::operator= ( const Store< N, I, K > & ) [protected]

template<class N, class I, class K = I>

bool DDI::Store< N, I, K >::readOnly ( ) const [inline]

Definition at line 86 of file Store.h.

{ return readOnly_; }

template<class N, class I, class K = I>

void DDI::Store< N, I, K >::setReadOnly ( bool b ) [inline]

Definition at line 85 of file Store.h.

{ readOnly_ = b; }

template<class N, class I, class K = I>

size_type DDI::Store< N, I, K >::size ( void ) const [inline]

Definition at line 67 of file Store.h.

{ return reg_.size(); }

template<class N , class I , class K >

void DDI::Store< N, I, K >::swap ( Store< N, I, K > & storeToSwap )

Definition at line 190 of file Store.h.

References DDI::Store< N, I, K >::readOnly_, and DDI::Store< N, I, K >::reg_.

                                                        {
  reg_.swap(storeToSwap.reg_);
  storeToSwap.readOnly_ = readOnly_;
}

Member Data Documentation

template<class N, class I, class K = I>

bool DDI::Store< N, I, K >::readOnly_ [protected]

Definition at line 95 of file Store.h.

Referenced by DDI::Store< DDName, DDRotationMatrix * >::readOnly(), DDI::Store< DDName, DDRotationMatrix * >::setReadOnly(), and DDI::Store< N, I, K >::swap().

template<class N, class I, class K = I>

registry_type DDI::Store< N, I, K >::reg_ [protected]

Definition at line 92 of file Store.h.

Referenced by DDI::Store< DDName, DDRotationMatrix * >::begin(), DDI::Store< DDName, DDRotationMatrix * >::end(), DDI::Store< DDName, DDRotationMatrix * >::size(), and DDI::Store< N, I, K >::swap().

DDI::Store< N, I, K > Class Template Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<class N, class I, class K = I> class DDI::Store< N, I, K >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class N, class I, class K = I>
class DDI::Store< N, I, K >