genie::Registry Class Reference

A registry. Provides the container for algorithm configuration parameters. More...

#include <Registry.h>

Public Member Functions
	Registry ()
	Registry (string name, bool isReadOnly=true)
	Registry (const Registry &)
virtual	~Registry ()
Registry &	operator= (const Registry &reg)
Registry &	operator+= (const Registry &reg)
void	operator() (RgKey key, int item)
void	operator() (RgKey key, bool item)
void	operator() (RgKey key, double item)
void	operator() (RgKey key, const char *item)
void	operator() (RgKey key, string item)
void	Lock (void)
	locks the registry More...
void	UnLock (void)
	unlocks the registry (doesn't unlock items) More...
bool	IsLocked (void) const
	checks registry lock More...
void	InhibitItemLocks (void)
	override individual item locks More...
void	RestoreItemLocks (void)
	restore individual item locks More...
bool	ItemLocksAreActive (void) const
	check if item locks are active More...
void	LockItem (RgKey key)
	locks the registry item More...
void	UnLockItem (RgKey key)
	unlocks the registry item More...
bool	ItemIsLocked (RgKey key) const
	check item lock More...
bool	ItemIsLocal (RgKey key) const
	local or global? More...
void	OverrideGlobalDef (RgKey key)
	let item override global default (i.e. a 'local' item) More...
void	LinkToGlobalDef (RgKey key)
	link its value to a global default (i.e. a 'global' item) More...
void	Set (RgIMapPair entry)
void	Set (RgKey key, RgBool item)
void	Set (RgKey key, RgInt item)
void	Set (RgKey key, RgDbl item)
void	Set (RgKey key, RgStr item)
void	Set (RgKey key, RgAlg item)
void	Set (RgKey key, RgCChAr item)
void	Set (RgKey key, RgH1F item)
void	Set (RgKey key, RgH2F item)
void	Set (RgKey key, RgTree item)
void	Get (RgKey key, const RegistryItemI *&item) const
void	Get (RgKey key, RgBool &item) const
void	Get (RgKey key, RgInt &item) const
void	Get (RgKey key, RgDbl &item) const
void	Get (RgKey key, RgStr &item) const
void	Get (RgKey key, RgAlg &item) const
void	Get (RgKey key, RgH1F &item) const
void	Get (RgKey key, RgH2F &item) const
void	Get (RgKey key, RgTree &item) const
RgBool	GetBool (RgKey key) const
RgInt	GetInt (RgKey key) const
RgDbl	GetDouble (RgKey key) const
RgStr	GetString (RgKey key) const
RgAlg	GetAlg (RgKey key) const
RgH1F	GetH1F (RgKey key) const
RgH2F	GetH2F (RgKey key) const
RgTree	GetTree (RgKey key) const
RgBool	GetBoolDef (RgKey key, RgBool def_opt, bool set_def=true)
RgInt	GetIntDef (RgKey key, RgInt def_opt, bool set_def=true)
RgDbl	GetDoubleDef (RgKey key, RgDbl def_opt, bool set_def=true)
RgStr	GetStringDef (RgKey key, RgStr def_opt, bool set_def=true)
RgAlg	GetAlgDef (RgKey key, RgAlg def_opt, bool set_def=true)
RgIMapConstIter	SafeFind (RgKey key) const
int	NEntries (void) const
	get number of items More...
bool	Exists (RgKey key) const
	item with input key exists? More...
bool	CanSetItem (RgKey key) const
	can I set the specifed item? More...
bool	DeleteEntry (RgKey key)
	delete the spcified item More...
void	SetName (string name)
	set the registry name More...
string	Name (void) const
	get the registry name More...
void	Print (ostream &stream) const
	print the registry to stream More...
void	Copy (const Registry &)
	copy the input registry More...
void	Append (const Registry &, RgKey pfx="")
	append the input registry. Entries already in the registry are not updated More...
void	Merge (const Registry &, RgKey pfx="")
	append the input registry. Entries already in the registry are updated More...
void	Clear (bool force=false)
	clear the registry More...
void	Init (void)
	initialize the registry More...
RgType_t	ItemType (RgKey key) const
	return item type More...
RgKeyList	FindKeys (RgKey key_part) const
	create list with all keys containing 'key_part' More...
const RgIMap &	GetItemMap (void) const
void	CopyToFolder (TFolder *folder) const
void	AssertExistence (RgKey key0) const
void	AssertExistence (RgKey key0, RgKey key1) const
void	AssertExistence (RgKey key0, RgKey key1, RgKey key2) const

Private Member Functions
RegistryItemI *	CloneRegistryItem (const RgKey &key) const
	Properly clone a registry Item according to its type. More...

Private Attributes
string	fName
	registry's name More...
bool	fIsReadOnly
	is read only? More...
bool	fInhibitItemLocks
RgIMap	fRegistry
	'key' -> 'value' map More...

Friends
ostream &	operator<< (ostream &stream, const Registry &registry)

Detailed Description

A registry. Provides the container for algorithm configuration parameters.

Author

Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

May 04, 2004

Copyright (c) 2003-2020, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 65 of file Registry.h.

Constructor & Destructor Documentation

Registry::Registry

(

)

Definition at line 85 of file Registry.cxx.

{
  this->Init();
}

Registry::Registry	(	string	name,
		bool	isReadOnly = true
	)

Definition at line 90 of file Registry.cxx.

                                               :
fName             ( name       ),
fIsReadOnly       ( isReadOnly ),
fInhibitItemLocks ( false      )
{

}

Registry::Registry

(

const Registry &

registry

)

Definition at line 98 of file Registry.cxx.

                                            :
fName("uninitialised"),
fIsReadOnly(false)
{
  this->Copy(registry);
}

Registry::~Registry ( )

virtual

Definition at line 105 of file Registry.cxx.

{
  this->Clear(true);
}

Member Function Documentation

void Registry::Append	(	const Registry &	registry,
		RgKey	pfx = ""
	)

append the input registry. Entries already in the registry are not updated

Definition at line 743 of file Registry.cxx.

{
// Appends the input registry entries (& their locks)

  LOG("Registry", pINFO)
       << "Appending registry " << registry.Name() << " to " << this->Name();

  if(this->IsLocked()) {
   LOG("Registry", pWARN) << "Registry is locked. Can't copy input entries!";
   return;
  }

  this->InhibitItemLocks();

  RgIMapConstIter reg_iter;
  for(reg_iter = registry.fRegistry.begin();
                      reg_iter != registry.fRegistry.end(); reg_iter++) {

     RgKey name     = reg_iter->first;
     RgKey new_name = prefix + name;

     if ( fRegistry.count( new_name ) > 0 ) continue ;

     RgType_t type  = reg_iter -> second -> TypeInfo();
     string   stype = RgType::AsString(type);

     LOG("Registry", pINFO)
         << "Copying [" << stype << "] item named = "
                                         << name << " as " << new_name;

     RegistryItemI * cri = registry.CloneRegistryItem( name ) ; // cloned registry item

     RgIMapPair reg_entry(new_name, cri);

     if ( ! fRegistry.insert(reg_entry).second ) {
         // The registry already contained an entry with key new_name
         //   so the new registryItem has to be deleted or we leak memory.
         //   This should not happened as a check is performed
         LOG("Registry", pERROR ) << "Failing to insert item " << new_name ;
         delete cri ;
     }
   } // loop on the incoming registry items
}

void Registry::AssertExistence

(

RgKey

key0

)

const

Definition at line 602 of file Registry.cxx.

{
  if ( ! this->Exists(key0) ) {
     LOG("Registry", pERROR) << (*this);
     LOG("Registry", pFATAL)
           << "*** Key: " << key0
             << " does not exist in registry: " << this->Name();
     exit(1);
  }
}

void Registry::AssertExistence	(	RgKey	key0,
		RgKey	key1
	)		const

Definition at line 613 of file Registry.cxx.

{
  this->AssertExistence(key0);
  this->AssertExistence(key1);
}

void Registry::AssertExistence	(	RgKey	key0,
		RgKey	key1,
		RgKey	key2
	)		const

Definition at line 619 of file Registry.cxx.

{
  this->AssertExistence(key0);
  this->AssertExistence(key1);
  this->AssertExistence(key2);
}

bool Registry::CanSetItem

(

RgKey

key

)

const

can I set the specifed item?

Definition at line 256 of file Registry.cxx.

{
  bool locked_item       = this->ItemIsLocked(key);
  bool active_item_locks = this->ItemLocksAreActive();
  bool locked_registry   = this->IsLocked();

  bool can_set = !locked_registry && ( !locked_item || !active_item_locks );

  return can_set;
}

void Registry::Clear

(

bool

force = false

)

clear the registry

Definition at line 864 of file Registry.cxx.

{
// clean all registry entries

  LOG("Registry", pINFO)
      << "Cleaning-up [force unlock = " << ((force)?"true":"false")
      << "] registry: " << this->Name();
  if(!force) {
   if(this->IsLocked()) {
      LOG("Registry", pWARN) << "Registry is locked. Can't clear its entries";
      return;
    }
  }
  RgIMapIter rit;
  for(rit = fRegistry.begin(); rit != fRegistry.end(); rit++) {
     RgKey           name = rit->first;
     RegistryItemI * item = rit->second;
     if(!item) {
       LOG("Registry", pWARN) << "Item with key = " << name << " is null!";
     }
     delete item;
     item = 0;
  }
  fRegistry.clear();
}

RegistryItemI * Registry::CloneRegistryItem ( const RgKey &  key ) const

private

Properly clone a registry Item according to its type.

Definition at line 890 of file Registry.cxx.

                                                                     {

        std::map<RgKey, RegistryItemI*>::const_iterator it = fRegistry.find( key ) ;

        if ( it == fRegistry.end() ) {
                LOG("Registry", pFATAL) << "Item " << key << " not found while cloning for registry " << Name() ;
                exit( 0 ) ;
        }

        RegistryItemI * ri  = it -> second ;

     bool     ilk   = ri->IsLocked();
     RgType_t type  = ri->TypeInfo();
     string   stype = RgType::AsString(type);

     RegistryItemI * cri = 0; // cloned registry item
     if (type == kRgBool)
           cri = new RegistryItem<RgBool>( GetBool(key), ilk);
     else if (type == kRgDbl)
           cri = new RegistryItem<RgDbl> ( GetDouble(key), ilk);
     else if (type == kRgInt)
           cri = new RegistryItem<RgInt> ( GetInt(key), ilk);
     else if (type == kRgStr)
           cri = new RegistryItem<RgStr> ( GetString(key), ilk);
     else if (type == kRgAlg)
           cri = new RegistryItem<RgAlg> ( GetAlg(key), ilk);
     else if (type == kRgH1F) {
           RgH1F histo = GetH1F(key);
           if(histo) {
               RgH1F chisto = new TH1F(*histo);
               LOG("Registry", pDEBUG) << chisto->GetName();
               cri = new RegistryItem<RgH1F>(chisto,ilk);
           } else {
             LOG("Registry", pERROR)
               << "Null TH1F with key = " << key << " - not copied";
           }
     } else if (type == kRgH2F) {
           RgH2F histo = GetH2F(key);
           if(histo) {
               RgH2F chisto = new TH2F(*histo);
               LOG("Registry", pDEBUG) << chisto->GetName();
               cri = new RegistryItem<RgH2F>(chisto,ilk);
           } else {
             LOG("Registry", pERROR)
               << "Null TH2F with key = " << key << " - not copied";
           }
     } else if (type == kRgTree) {
           RgTree tree = GetTree(key);
           if(tree) {
               //TTree * ctree = new TTree(*tree);
               TTree * ctree = tree->CopyTree("1");
               LOG("Registry", pDEBUG) << ctree->GetName();
               cri = new RegistryItem<RgTree>(ctree,ilk);
           } else {
             LOG("Registry", pERROR)
               << "Null TTree with key = " << key << " - not copied";
           }
     } else {

       LOG( "Registry", pFATAL ) << "Item " << key << " not cloned because its type is not implemented " ;
       exit( 0 ) ;
     }

     return cri ;

}

void Registry::Copy

(

const Registry &

registry

)

copy the input registry

Definition at line 722 of file Registry.cxx.

{
// Copies the input registry
//
  LOG("Registry", pINFO)
         << "Copying registry " << registry.Name() << " to " << this->Name();

  if(this->IsLocked()) {
   LOG("Registry", pWARN) << "Registry is locked. Can't copy input entries!";
   return;
  }

  this->Init();
  this->Clear();
  this->Append(registry);

  fName             = registry.fName;
  fIsReadOnly       = registry.fIsReadOnly;
  fInhibitItemLocks = registry.fInhibitItemLocks;
}

void Registry::CopyToFolder

(

TFolder *

folder

)

const

Definition at line 626 of file Registry.cxx.

{
  LOG("Registry", pINFO) << "Converting Registry to TFolder";

  folder->SetOwner(true);

  RgIMapConstIter reg_iter;

  for(reg_iter = this->fRegistry.begin();
                          reg_iter != this->fRegistry.end(); reg_iter++) {

     ostringstream   entry;
     string          key   = reg_iter->first;
     RegistryItemI * ritem = reg_iter->second;

     RgType_t type  = ritem->TypeInfo();
     string   stype = RgType::AsString(type);

     entry << "key:" << key << ";type:" << stype;

     if(type == kRgBool) {
        entry << ";value: " << this->GetBool(key);
        LOG("Registry", pINFO) << "entry = " << entry.str();
        folder->Add(new TObjString(entry.str().c_str()));
     }
     else if (type == kRgDbl) {
        entry << ";value: " << this->GetDouble(key);
        LOG("Registry", pINFO) << "entry = " << entry.str();
        folder->Add(new TObjString(entry.str().c_str()));
     }
     else if (type == kRgInt) {
        entry << ";value: " << this->GetInt(key);
        LOG("Registry", pINFO) << "entry = " << entry.str();
        folder->Add(new TObjString(entry.str().c_str()));
     }
     else if (type == kRgStr) {
        entry << ";value: " << this->GetString(key);
        LOG("Registry", pINFO) << "entry = " << entry.str();
        folder->Add(new TObjString(entry.str().c_str()));
     }
     else if (type == kRgAlg) {
        entry << ";value: " << this->GetAlg(key).name
              << "/" << this->GetAlg(key).config;
        LOG("Registry", pINFO) << "entry = " << entry.str();
        folder->Add(new TObjString(entry.str().c_str()));

     } else if (type == kRgH1F) {
     } else if (type == kRgH2F) {
     } else if (type == kRgTree) {
     } else {}
  }// registry iterator
}

bool Registry::DeleteEntry

(

RgKey

key

)

delete the spcified item

Definition at line 569 of file Registry.cxx.

{
  if(!fIsReadOnly && Exists(key)) {
      RgIMapIter entry = fRegistry.find(key);
      RegistryItemI * item = entry->second;
      delete item;
      item = 0;
      fRegistry.erase(entry);
      return true;
  }
  return false;
}

bool Registry::Exists

(

RgKey

key

)

const

item with input key exists?

Definition at line 563 of file Registry.cxx.

{
  RgIMapConstIter entry = fRegistry.find(key);
  return (entry!=fRegistry.end());
}

RgKeyList Registry::FindKeys

(

RgKey

key_part

)

const

create list with all keys containing 'key_part'

Definition at line 840 of file Registry.cxx.

{
  RgKeyList klist;

  RgIMapConstIter reg_iter = fRegistry.begin();
  for( ; reg_iter != fRegistry.end(); reg_iter++) {
    RgKey key = reg_iter->first;
    if (key.find(key_part) != string::npos) {
      klist.push_back(key);
    }
  }

  return klist;
}

void Registry::Get	(	RgKey	key,
		const RegistryItemI *&	item
	)		const

Definition at line 325 of file Registry.cxx.

{
  RgIMapConstIter entry = this->SafeFind(key);
  item = entry->second;
}

void Registry::Get	(	RgKey	key,
		RgBool &	item
	)		const

Definition at line 331 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Get an RgBool item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgBool> * ri = dynamic_cast<RegistryItem<RgBool>*> (rib);

#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Item value = " << ri->Data();
#endif
  item = ri->Data();
}

void genie::Registry::Get	(	RgKey	key,
		RgInt &	item
	)		const

void Registry::Get	(	RgKey	key,
		RgDbl &	item
	)		const

Definition at line 363 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgDbl item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgDbl> * ri = dynamic_cast<RegistryItem<RgDbl>*> (rib);

#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Item value = " << ri->Data();
#endif
  item = ri->Data();
}

void Registry::Get	(	RgKey	key,
		RgStr &	item
	)		const

Definition at line 379 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgStr item with  key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgStr> * ri = dynamic_cast<RegistryItem<RgStr>*> (rib);

#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Item value = " << ri->Data();
#endif
  item = ri->Data();
}

void Registry::Get	(	RgKey	key,
		RgAlg &	item
	)		const

Definition at line 395 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgAlg item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgAlg> * ri = dynamic_cast<RegistryItem<RgAlg>*> (rib);

#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Item value = " << ri->Data();
#endif

  item = ri->Data();
}

void Registry::Get	(	RgKey	key,
		RgH1F &	item
	)		const

Definition at line 412 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgH1F item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgH1F> *ri = dynamic_cast<RegistryItem<RgH1F>*> (rib);
  item = ri->Data();

  if(!item) {
    LOG("Registry", pWARN) << "Returned NULL ptr for TH1F param = " << key;
  }
}

void Registry::Get	(	RgKey	key,
		RgH2F &	item
	)		const

Definition at line 428 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgH2F item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgH2F> *ri = dynamic_cast<RegistryItem<RgH2F>*> (rib);
  item = ri->Data();

  if(!item) {
    LOG("Registry", pWARN) << "Returned NULL ptr for TH2F param = " << key;
  }
}

void Registry::Get	(	RgKey	key,
		RgTree &	item
	)		const

Definition at line 444 of file Registry.cxx.

{
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
  LOG("Registry", pDEBUG) << "Getting an RgTree item with key: " << key;
#endif

  RgIMapConstIter entry = this->SafeFind(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgTree> *ri =  dynamic_cast<RegistryItem<RgTree>*> (rib);
  item = ri->Data();

  if(!item) {
    LOG("Registry", pWARN) << "Returned NULL ptr for TTree param = " << key;
  }
}

RgAlg Registry::GetAlg

(

RgKey

key

)

const

Definition at line 488 of file Registry.cxx.

{
  RgAlg value;
  this->Get(key, value);
  return value;
}

RgAlg Registry::GetAlgDef	(	RgKey	key,
		RgAlg	def_opt,
		bool	set_def = true
	)

Definition at line 545 of file Registry.cxx.

{
  return GetValueOrUseDefault(this, key, def_opt, set_def);
}

RgBool Registry::GetBool

(

RgKey

key

)

const

Definition at line 460 of file Registry.cxx.

{
  RgBool value;
  this->Get(key, value);
  return value;
}

RgBool Registry::GetBoolDef	(	RgKey	key,
		RgBool	def_opt,
		bool	set_def = true
	)

Definition at line 525 of file Registry.cxx.

{
  return GetValueOrUseDefault(this, key, def_opt, set_def);
}

RgDbl Registry::GetDouble

(

RgKey

key

)

const

Definition at line 474 of file Registry.cxx.

{
  RgDbl value;
  this->Get(key, value);
  return value;
}

double Registry::GetDoubleDef	(	RgKey	key,
		RgDbl	def_opt,
		bool	set_def = true
	)

Definition at line 535 of file Registry.cxx.

{
  return GetValueOrUseDefault(this, key, def_opt, set_def);
}

RgH1F Registry::GetH1F

(

RgKey

key

)

const

Definition at line 495 of file Registry.cxx.

{
  RgIMapConstIter entry = fRegistry.find(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgH1F> *ri = dynamic_cast<RegistryItem<RgH1F>*> (rib);

  RgH1F item = ri->Data();
  return item;
}

RgH2F Registry::GetH2F

(

RgKey

key

)

const

Definition at line 505 of file Registry.cxx.

{
  RgIMapConstIter entry = fRegistry.find(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgH2F> *ri = dynamic_cast<RegistryItem<RgH2F>*> (rib);

  RgH2F item = ri->Data();
  return item;
}

RgInt Registry::GetInt

(

RgKey

key

)

const

Definition at line 467 of file Registry.cxx.

{
  RgInt value;
  this->Get(key, value);
  return value;
}

int Registry::GetIntDef	(	RgKey	key,
		RgInt	def_opt,
		bool	set_def = true
	)

Definition at line 530 of file Registry.cxx.

{
  return GetValueOrUseDefault(this, key, def_opt, set_def);
}

const RgIMap& genie::Registry::GetItemMap ( void  ) const

inline

Definition at line 161 of file Registry.h.

{ return fRegistry; }

RgStr Registry::GetString

(

RgKey

key

)

const

Definition at line 481 of file Registry.cxx.

{
  RgStr value;
  this->Get(key, value);
  return value;
}

string Registry::GetStringDef	(	RgKey	key,
		RgStr	def_opt,
		bool	set_def = true
	)

Definition at line 540 of file Registry.cxx.

{
  return GetValueOrUseDefault(this, key, def_opt, set_def);
}

RgTree Registry::GetTree

(

RgKey

key

)

const

Definition at line 515 of file Registry.cxx.

{
  RgIMapConstIter entry = fRegistry.find(key);
  RegistryItemI * rib = entry->second;
  RegistryItem<RgTree> *ri = dynamic_cast<RegistryItem<RgTree>*> (rib);

  RgTree item = ri->Data();
  return item;
}

void Registry::InhibitItemLocks

(

void

)

override individual item locks

Definition at line 163 of file Registry.cxx.

{
  fInhibitItemLocks = true;
}

void Registry::Init

(

void

)

initialize the registry

Definition at line 855 of file Registry.cxx.

{
// initialize registry properties

  fName              = "NoName";
  fIsReadOnly        = false;
  fInhibitItemLocks  = false;
}

bool Registry::IsLocked

(

void

)

const

checks registry lock

Definition at line 158 of file Registry.cxx.

{
  return fIsReadOnly;
}

bool Registry::ItemIsLocal

(

RgKey

key

)

const

local or global?

Definition at line 178 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     bool is_local = entry->second->IsLocal();
     return is_local;
  } else {
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
     LOG("Registry", pDEBUG)
        << "*** Was asked to check 'local' flag on non-existing item: ["
        << key << "]";
#endif
  }
  return false;
}

bool Registry::ItemIsLocked

(

RgKey

key

)

const

check item lock

Definition at line 218 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     bool is_locked = entry->second->IsLocked();
     return is_locked;
  } else {
/*
     LOG("Registry", pDEBUG)
        << "*** Was asked to check lock on non-existing item: ["
        << key << "]";
*/
  }
  return false;
}

bool Registry::ItemLocksAreActive

(

void

)

const

check if item locks are active

Definition at line 173 of file Registry.cxx.

{
  return !fInhibitItemLocks;
}

RgType_t Registry::ItemType

(

RgKey

key

)

const

return item type

Definition at line 829 of file Registry.cxx.

{
  RgIMapConstIter reg_iter = fRegistry.find(key);
  if(reg_iter != fRegistry.end()) {
     RegistryItemI * ri = reg_iter->second;
     RgType_t type  = ri->TypeInfo();
     return type;
  }
  return kRgUndefined;
}

void Registry::LinkToGlobalDef

(

RgKey

key

)

link its value to a global default (i.e. a 'global' item)

Definition at line 206 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     entry->second->SetLocal(false);
  } else {
     LOG("Registry", pWARN)
        << "*** Can't give 'global' status to  non-existem item ["
        << key << "]";
  }
}

void Registry::Lock

(

void

)

locks the registry

Definition at line 148 of file Registry.cxx.

{
  fIsReadOnly = true;
}

void Registry::LockItem

(

RgKey

key

)

locks the registry item

Definition at line 234 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     entry->second->Lock();
  } else {
     LOG("Registry", pWARN)
           << "*** Can't lock non-existem item [" << key << "]";
  }
}

void Registry::Merge	(	const Registry &	registry,
		RgKey	pfx = ""
	)

append the input registry. Entries already in the registry are updated

Definition at line 787 of file Registry.cxx.

{
// Add the input registry entries (& their locks)
// and updated entries already present

  LOG("Registry", pINFO)
       << "Appending registry " << registry.Name() << " to " << this->Name();

  if(this->IsLocked()) {
   LOG("Registry", pWARN) << "Registry is locked. Can't copy input entries!";
   return;
  }

  this->InhibitItemLocks();

  RgIMapConstIter reg_iter;
  for(reg_iter = registry.fRegistry.begin();
                      reg_iter != registry.fRegistry.end(); reg_iter++) {

     RgKey name     = reg_iter->first;
     RgKey new_name = prefix + name;

     RgType_t type  = reg_iter -> second -> TypeInfo();
     string   stype = RgType::AsString(type);

     LOG("Registry", pINFO)
         << "Copying [" << stype << "] item named = "
                                         << name << " as " << new_name;

     RegistryItemI * cri = registry.CloneRegistryItem( name ) ; // cloned registry item

     if ( fRegistry.count( new_name ) > 0 ) {

       RegistryItemI * old_ri = fRegistry[new_name] ;
           delete old_ri ;
     }

     fRegistry[new_name] = cri ;

   } // loop on the incoming registry items

}//____________________________________________________________________________

string Registry::Name

(

void

)

const

get the registry name

Definition at line 597 of file Registry.cxx.

{
  return fName;
}

int Registry::NEntries

(

void

)

const

get number of items

Definition at line 582 of file Registry.cxx.

{
  RgIMapSizeType reg_size = fRegistry.size();
  return (const int) reg_size;
}

void Registry::operator()	(	RgKey	key,
		int	item
	)

Definition at line 110 of file Registry.cxx.

{
  this->Set(key, item);
}

void genie::Registry::operator()	(	RgKey	key,
		bool	item
	)

void Registry::operator()	(	RgKey	key,
		double	item
	)

Definition at line 120 of file Registry.cxx.

{
  this->Set(key, item);
}

void genie::Registry::operator()	(	RgKey	key,
		const char *	item
	)

void Registry::operator()	(	RgKey	key,
		string	item
	)

Definition at line 131 of file Registry.cxx.

{
  this->Set(key, item);
}

Registry & Registry::operator+=

(

const Registry &

reg

)

Definition at line 142 of file Registry.cxx.

{
  this->Append(reg);
  return (*this);
}

Registry & Registry::operator=

(

const Registry &

reg

)

Definition at line 136 of file Registry.cxx.

{
  this->Copy(reg);
  return (*this);
}

void Registry::OverrideGlobalDef

(

RgKey

key

)

let item override global default (i.e. a 'local' item)

Definition at line 194 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     entry->second->SetLocal(true);
  } else {
     LOG("Registry", pWARN)
        << "*** Can't give 'local' status to  non-existem item ["
        << key << "]";
  }
}

void Registry::Print

(

ostream &

stream

)

const

print the registry to stream

Definition at line 679 of file Registry.cxx.

{
// Prints the registry to the specified stream
//
   stream << endl;
   stream << "[-] Registry name: [" << Name() << "]";

   stream << " - Write Status: ";
   if(fIsReadOnly)       { stream << "[locked]";   }
   else                  { stream << "[unlocked]"; }

   stream << " - Inhibited Item Locking: ";
   if(fInhibitItemLocks) { stream << "[on]";       }
   else                  { stream << "[off]";      }

   stream << " - # entries: " << setfill(' ') << setw(3) << fRegistry.size()
          << endl;

   RgIMapConstIter rcit = fRegistry.begin();
   for( ; rcit != fRegistry.end(); rcit++) {

     RgKey           key   = rcit->first;
     RegistryItemI * ritem = rcit->second;
     if(ritem) {
        RgType_t type  = ritem->TypeInfo();
        string   stype = RgType::AsString(type);

        string key_lbl  = string("> ") + key;
        string type_lbl = string("[") + stype + string("] ");
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
        LOG("Registry", pDEBUG)
                      << "Printing [" << stype << "] item named = " << key;
#endif
        stream << " |" << setfill('-') << setw(50) << key_lbl
               << setfill(' ') << setw(10) << type_lbl;
        ritem->Print(stream);
        stream << endl;
     } else {
        LOG("Registry", pERROR) << "Null RegistryItemI with key = " << key;
     }
   }// registry iterator
}

void Registry::RestoreItemLocks

(

void

)

restore individual item locks

Definition at line 168 of file Registry.cxx.

{
  fInhibitItemLocks = false;
}

RgIMapConstIter Registry::SafeFind

(

RgKey

key

)

const

Definition at line 550 of file Registry.cxx.

{
  RgIMapConstIter entry = fRegistry.find(key);
  if (entry!=fRegistry.end()) {
    return entry;
  }
  LOG("Registry/SafeFind", pFATAL)
       << "*** Key: " << key
       << " does not exist in registry: " << this->Name();
  gAbortingInErr = true;
  exit(1);
}

void Registry::Set

(

RgIMapPair

entry

)

Definition at line 267 of file Registry.cxx.

{
  RgKey key = entry.first;
  if( this->CanSetItem(key) ) {
    this->DeleteEntry(key);
    fRegistry.insert(entry);
  } else {
     LOG("Registry", pWARN)
             << "*** Registry item [" << key << "] can not be set";
  }
}

void Registry::Set	(	RgKey	key,
		RgBool	item
	)

Definition at line 279 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void genie::Registry::Set	(	RgKey	key,
		RgInt	item
	)

void Registry::Set	(	RgKey	key,
		RgDbl	item
	)

Definition at line 289 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::Set	(	RgKey	key,
		RgStr	item
	)

Definition at line 300 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::Set	(	RgKey	key,
		RgAlg	item
	)

Definition at line 305 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::Set	(	RgKey	key,
		RgCChAr	item
	)

Definition at line 294 of file Registry.cxx.

{
  RgStr item2 = RgStr(item); // "const char *" -> "string"
  this->Set(key, item2);
}

void Registry::Set	(	RgKey	key,
		RgH1F	item
	)

Definition at line 310 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::Set	(	RgKey	key,
		RgH2F	item
	)

Definition at line 315 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::Set	(	RgKey	key,
		RgTree	item
	)

Definition at line 320 of file Registry.cxx.

{
  SetRegistryItem(this, key, item); // call templated set method
}

void Registry::SetName

(

string

name

)

set the registry name

Definition at line 588 of file Registry.cxx.

{
  if(! fIsReadOnly) fName = name;
  else {
     LOG("Registry", pWARN)
        << "*** Registry is locked - Can not change its name";
  }
}

void Registry::UnLock

(

void

)

unlocks the registry (doesn't unlock items)

Definition at line 153 of file Registry.cxx.

{
  fIsReadOnly = false;
}

void Registry::UnLockItem

(

RgKey

key

)

unlocks the registry item

Definition at line 245 of file Registry.cxx.

{
  if( this->Exists(key) ) {
     RgIMapConstIter entry = fRegistry.find(key);
     entry->second->UnLock();
  } else {
    LOG("Registry", pWARN)
       << "*** Can't unlock non-existem item [" << key << "]";
  }
}

Friends And Related Function Documentation

ostream& operator<< ( ostream &  stream, const Registry &  registry  )

friend

Definition at line 77 of file Registry.cxx.

 {
   registry.Print(stream);
   return stream;
 }

Member Data Documentation

bool genie::Registry::fInhibitItemLocks

private

Definition at line 182 of file Registry.h.

bool genie::Registry::fIsReadOnly

private

is read only?

Definition at line 181 of file Registry.h.

string genie::Registry::fName

private

registry's name

Definition at line 180 of file Registry.h.

RgIMap genie::Registry::fRegistry

private

'key' -> 'value' map

Definition at line 183 of file Registry.h.

---

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

• Generator/src/Framework/Registry/Registry.h
• Generator/src/Framework/Registry/Registry.cxx