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

#include <Store.h>

Public Types
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

Public Member Functions
auto	begin ()
void	clear ()
prep_type	create (const name_type &)
prep_type	create (const name_type &, pimpl_type)
auto	end ()
bool	isDefined (const name_type &n) const
bool	readOnly () const
void	setReadOnly (bool b)
auto	size () const
	Store ()
void	swap (Store &)
	~Store ()

Protected Member Functions
Store &	operator= (const Store &)
	Store (const Store &)

Protected Attributes
bool	readOnly_
std::map< name_type, prep_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::iterator DDI::Store< N, I, K >::iterator

Definition at line 46 of file Store.h.

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

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

Definition at line 42 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 44 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 45 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 43 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 68 of file Store.h.

: readOnly_(false) { }

template<class N , class I , class K >

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

(

)

Definition at line 112 of file Store.h.

   {
      for( auto it : reg_ ) {
         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>

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

inline

Definition at line 48 of file Store.h.

{ return reg_.begin(); }

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

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

(

)

Referenced by Vispa.Views.WidgetView.WidgetView::closeEvent(), Vispa.Views.BoxDecayView.BoxDecayView::closeEvent(), Vispa.Share.FindAlgorithm.FindAlgorithm::findUsingFindDialog(), Vispa.Views.LineDecayView.LineDecayView::setDataObjects(), Vispa.Views.WidgetView.WidgetView::setDataObjects(), BeautifulSoup.Tag::setString(), Vispa.Views.TreeView.TreeView::updateContent(), Vispa.Views.TableView.TableView::updateContent(), Vispa.Views.BoxDecayView.BoxDecayView::updateContent(), and Vispa.Views.PropertyView.PropertyView::updateContent().

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 80 of file Store.h.

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

   {
      prep_type tmp = 0;
      auto 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 94 of file Store.h.

References Exception, AlCaHLTBitMon_ParallelJobs::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;
      auto result = reg_.insert(std::make_pair(n,tmp));
      if (!result.second) {
         delete result.first->second->second;
         result.first->second->second = p;
      }
      else {
         result.first->second = new Rep_type(n,p);
      }
      return result.first->second;
   }

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

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

inline

Definition at line 49 of file Store.h.

Referenced by Types.LuminosityBlockRange::cppID(), and Types.EventRange::cppID().

{ 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 123 of file Store.h.

References query::result.

   {
      if (readOnly_) edm::LogWarning("DetectorDescriptionStore") << " Store is locked and most likely empty.  isDefined will be false.";
      auto 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 66 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 65 of file Store.h.

{ readOnly_ = b; }

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

auto DDI::Store< N, I, K >::size ( void  ) const

inline

Definition at line 50 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 137 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 75 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>

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

protected

Definition at line 72 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().