genie::Registry Class Reference

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

#include "/cvmfs/nova.opensciencegrid.org/externals/genie/v3_00_06_p01a/Linux64bit+3.10-2.17-e19-debug/GENIE-Generator/src/Framework/Registry/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 <costas.andreopoulos stfc.ac.uk> University of Liverpool & STFC Rutherford Appleton Lab

May 04, 2004

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

Definition at line 66 of file Registry.h.

Constructor & Destructor Documentation

Registry::Registry

(

)

Definition at line 100 of file Registry.cxx.

References Init().

{
  this->Init();
}

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

Definition at line 105 of file Registry.cxx.

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

}

Registry::Registry

(

const Registry &

registry

)

Definition at line 113 of file Registry.cxx.

References Copy().

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

Registry::~Registry ( )

virtual

Definition at line 120 of file Registry.cxx.

References Clear().

{
  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 758 of file Registry.cxx.

References genie::RgType::AsString(), CloneRegistryItem(), fRegistry, InhibitItemLocks(), IsLocked(), LOG, Name(), pERROR, pINFO, pWARN, and moon_position_table_new3::second.

Referenced by Copy(), and operator+=().

{
// 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 617 of file Registry.cxx.

References Exists(), exit(), LOG, Name(), pERROR, and pFATAL.

Referenced by AssertExistence(), and GetItemMap().

{
  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 628 of file Registry.cxx.

References AssertExistence().

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

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

Definition at line 634 of file Registry.cxx.

References AssertExistence().

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

bool Registry::CanSetItem

(

RgKey

key

)

const

can I set the specifed item?

Definition at line 271 of file Registry.cxx.

References IsLocked(), ItemIsLocked(), and ItemLocksAreActive().

Referenced by Set().

{
  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 879 of file Registry.cxx.

References fRegistry, IsLocked(), LOG, Name(), pINFO, and pWARN.

Referenced by Copy(), and ~Registry().

{
// 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 905 of file Registry.cxx.

References genie::RgType::AsString(), exit(), fRegistry, GetAlg(), GetBool(), GetDouble(), GetH1F(), GetH2F(), GetInt(), GetString(), GetTree(), histo, genie::RegistryItemI::IsLocked(), it, genie::kRgAlg, genie::kRgBool, genie::kRgDbl, genie::kRgH1F, genie::kRgH2F, genie::kRgInt, genie::kRgStr, genie::kRgTree, LOG, Name(), pDEBUG, pERROR, pFATAL, moon_position_table_new3::second, compareCafs::tree, and genie::RegistryItemI::TypeInfo().

Referenced by Append(), GetItemMap(), and Merge().

                                                                     {

        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 737 of file Registry.cxx.

References Append(), Clear(), fInhibitItemLocks, fIsReadOnly, fName, Init(), IsLocked(), LOG, Name(), pINFO, and pWARN.

Referenced by main(), operator=(), and Registry().

{
// 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 641 of file Registry.cxx.

References genie::RgType::AsString(), RgAlg::config, HTMLTools::entry(), fRegistry, GetAlg(), GetBool(), GetDouble(), GetInt(), GetString(), findDuplicateFiles::key, genie::kRgAlg, genie::kRgBool, genie::kRgDbl, genie::kRgH1F, genie::kRgH2F, genie::kRgInt, genie::kRgStr, genie::kRgTree, LOG, RgAlg::name, pINFO, and genie::RegistryItemI::TypeInfo().

Referenced by GetItemMap(), and genie::NtpMCJobConfig::Load().

{
  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 584 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fIsReadOnly, and fRegistry.

Referenced by Set().

{
  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 578 of file Registry.cxx.

References HTMLTools::entry(), and fRegistry.

Referenced by AssertExistence(), DeleteEntry(), genie::utils::config::GetDoubleKeyPDG(), genie::utils::config::GetDoubleKeyRangeNucA(), genie::GetValueOrUseDefault(), ItemIsLocal(), ItemIsLocked(), LinkToGlobalDef(), LockItem(), OverrideGlobalDef(), and UnLockItem().

{
  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 855 of file Registry.cxx.

References fRegistry, and findDuplicateFiles::key.

Referenced by genie::Decayer::LoadConfig(), and main().

{
  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 340 of file Registry.cxx.

References HTMLTools::entry(), and SafeFind().

Referenced by CheckUnitarityLimit(), GetAlg(), GetBool(), GetDouble(), GetInt(), GetString(), genie::GetValueOrUseDefault(), and main().

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

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

Definition at line 346 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, and SafeFind().

{
#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 Registry::Get	(	RgKey	key,
		RgInt &	item
	)		const

Definition at line 362 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, and SafeFind().

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

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

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

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

Definition at line 378 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, and SafeFind().

{
#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 394 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, and SafeFind().

{
#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 410 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, and SafeFind().

{
#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 427 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, pWARN, and SafeFind().

{
#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 443 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, pWARN, and SafeFind().

{
#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 459 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), findDuplicateFiles::key, LOG, pDEBUG, pWARN, and SafeFind().

{
#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 503 of file Registry.cxx.

References Get().

Referenced by CloneRegistryItem(), CopyToFolder(), genie::IBDXSecMap::LoadConfig(), genie::NuclearModelMap::LoadConfig(), genie::PauliBlocker::LoadModelType(), and genie::utils::nuclear::NuclQELXSecSuppression().

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

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

Definition at line 560 of file Registry.cxx.

References genie::GetValueOrUseDefault().

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

RgBool Registry::GetBool

(

RgKey

key

)

const

Definition at line 475 of file Registry.cxx.

References Get().

Referenced by CloneRegistryItem(), CopyToFolder(), genie::utils::gsl::d2XSecRESFast_dWQ2_E::d2XSecRESFast_dWQ2_E(), genie::Decayer::LoadConfig(), and main().

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

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

Definition at line 540 of file Registry.cxx.

References genie::GetValueOrUseDefault().

Referenced by genie::utils::gsl::d2XSecRESFast_dWQ2_E::d2XSecRESFast_dWQ2_E(), and main().

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

RgDbl Registry::GetDouble

(

RgKey

key

)

const

Definition at line 489 of file Registry.cxx.

References Get().

Referenced by CloneRegistryItem(), CopyToFolder(), genie::utils::gsl::d2XSecRESFast_dWQ2_E::d2XSecRESFast_dWQ2_E(), genie::GVldContext::Decode(), genie::KPhaseSpace::GetTMaxDFR(), genie::NewQELXSec::Integrate(), and main().

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

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

Definition at line 550 of file Registry.cxx.

References genie::GetValueOrUseDefault().

Referenced by genie::utils::gsl::d2XSecRESFast_dWQ2_E::d2XSecRESFast_dWQ2_E(), genie::utils::config::GetDoubleKeyPDG(), genie::utils::config::GetDoubleKeyRangeNucA(), and main().

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

RgH1F Registry::GetH1F

(

RgKey

key

)

const

Definition at line 510 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), and fRegistry.

Referenced by CloneRegistryItem().

{
  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 520 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), and fRegistry.

Referenced by CloneRegistryItem().

{
  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 482 of file Registry.cxx.

References Get().

Referenced by genie::EventGeneratorListAssembler::AssembleGeneratorList(), CloneRegistryItem(), CopyToFolder(), and main().

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

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

Definition at line 545 of file Registry.cxx.

References genie::GetValueOrUseDefault().

Referenced by main().

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

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

inline

Definition at line 162 of file Registry.h.

References AssertExistence(), CloneRegistryItem(), CopyToFolder(), PandAna.Demos.tute_pid_validation::folder, and fRegistry.

Referenced by genie::Algorithm::ExtractLocalConfig(), genie::Algorithm::ExtractLowerConfig(), genie::Algorithm::FindConfig(), genie::FGMBodekRitchie::LoadConfig(), genie::NuclearModelMap::LoadConfig(), and genie::SmithMonizUtils::LoadConfig().

{ return fRegistry; }

RgStr Registry::GetString

(

RgKey

key

)

const

Definition at line 496 of file Registry.cxx.

References Get().

Referenced by CloneRegistryItem(), CopyToFolder(), genie::Algorithm::FindConfig(), genie::NewQELXSec::Integrate(), and genie::P33PaschosLalakulichPXSec::XSec().

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

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

Definition at line 555 of file Registry.cxx.

References genie::GetValueOrUseDefault().

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

RgTree Registry::GetTree

(

RgKey

key

)

const

Definition at line 530 of file Registry.cxx.

References genie::RegistryItem< T >::Data(), HTMLTools::entry(), and fRegistry.

Referenced by CloneRegistryItem().

{
  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 178 of file Registry.cxx.

References fInhibitItemLocks.

Referenced by Append(), main(), and Merge().

{
  fInhibitItemLocks = true;
}

void Registry::Init

(

void

)

initialize the registry

Definition at line 870 of file Registry.cxx.

References fInhibitItemLocks, fIsReadOnly, and fName.

Referenced by Copy(), and Registry().

{
// initialize registry properties

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

bool Registry::IsLocked

(

void

)

const

checks registry lock

Definition at line 173 of file Registry.cxx.

References fIsReadOnly.

Referenced by Append(), CanSetItem(), Clear(), Copy(), genie::GetValueOrUseDefault(), and Merge().

{
  return fIsReadOnly;
}

bool Registry::ItemIsLocal

(

RgKey

key

)

const

local or global?

Definition at line 193 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fRegistry, LOG, and pDEBUG.

Referenced by genie::Algorithm::FindConfig(), and genie::GetValueOrUseDefault().

{
  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 233 of file Registry.cxx.

References HTMLTools::entry(), Exists(), and fRegistry.

Referenced by CanSetItem(), and genie::SetRegistryItem().

{
  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 188 of file Registry.cxx.

References fInhibitItemLocks.

Referenced by CanSetItem().

{
  return !fInhibitItemLocks;
}

RgType_t Registry::ItemType

(

RgKey

key

)

const

return item type

Definition at line 844 of file Registry.cxx.

References fRegistry, genie::kRgUndefined, and genie::RegistryItemI::TypeInfo().

Referenced by main().

{
  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 221 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fRegistry, LOG, and pWARN.

Referenced by genie::GetValueOrUseDefault().

{
  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 163 of file Registry.cxx.

References fIsReadOnly.

Referenced by genie::GetValueOrUseDefault(), genie::AlgConfigPool::LoadRegistries(), and main().

{
  fIsReadOnly = true;
}

void Registry::LockItem

(

RgKey

key

)

locks the registry item

Definition at line 249 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fRegistry, LOG, and pWARN.

Referenced by main().

{
  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 802 of file Registry.cxx.

References genie::RgType::AsString(), CloneRegistryItem(), fRegistry, InhibitItemLocks(), IsLocked(), LOG, Name(), pINFO, pWARN, and moon_position_table_new3::second.

{
// 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 612 of file Registry.cxx.

References fName.

Referenced by Append(), AssertExistence(), Clear(), CloneRegistryItem(), genie::Algorithm::Configure(), Copy(), genie::Algorithm::ExtractLocalConfig(), genie::Algorithm::ExtractLowerConfig(), Merge(), Print(), and SafeFind().

{
  return fName;
}

int Registry::NEntries

(

void

)

const

get number of items

Definition at line 597 of file Registry.cxx.

References fRegistry.

Referenced by genie::Algorithm::Configure().

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

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

Definition at line 125 of file Registry.cxx.

References Set().

Referenced by operator()().

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

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

Definition at line 130 of file Registry.cxx.

References Set().

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

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

Definition at line 135 of file Registry.cxx.

References findDuplicateFiles::key, operator()(), and Set().

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

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

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

Definition at line 146 of file Registry.cxx.

References Set().

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

Registry & Registry::operator+=

(

const Registry &

reg

)

Definition at line 157 of file Registry.cxx.

References Append().

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

Registry & Registry::operator=

(

const Registry &

reg

)

Definition at line 151 of file Registry.cxx.

References Copy().

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

void Registry::OverrideGlobalDef

(

RgKey

key

)

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

Definition at line 209 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fRegistry, LOG, and pWARN.

{
  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 694 of file Registry.cxx.

References genie::RgType::AsString(), allTimeWatchdog::endl, fInhibitItemLocks, fIsReadOnly, fRegistry, findDuplicateFiles::key, LOG, Name(), pDEBUG, pERROR, genie::RegistryItemI::Print(), string, and genie::RegistryItemI::TypeInfo().

Referenced by genie::operator<<().

{
// 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 183 of file Registry.cxx.

References fInhibitItemLocks.

{
  fInhibitItemLocks = false;
}

RgIMapConstIter Registry::SafeFind

(

RgKey

key

)

const

Definition at line 565 of file Registry.cxx.

References HTMLTools::entry(), exit(), fRegistry, genie::gAbortingInErr, LOG, Name(), and pFATAL.

Referenced by Get().

{
  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 282 of file Registry.cxx.

References CanSetItem(), DeleteEntry(), fRegistry, findDuplicateFiles::key, LOG, and pWARN.

Referenced by genie::AlgConfigPool::AddBasicParameter(), genie::AlgConfigPool::AddRootObjParameter(), genie::HadronTransporter::Configure(), genie::EmpiricalMECPXSec2015::Configure(), genie::QPMDISPXSec::Configure(), genie::QPMDMDISPXSec::Configure(), genie::SmithMonizQELCCXSec::Configure(), genie::QELEventGeneratorSM::Configure(), genie::SmithMonizQELCCPXSec::Configure(), genie::NuclearModelMap::Configure(), genie::GetValueOrUseDefault(), IncrementCoefficients(), main(), operator()(), Set(), genie::SetRegistryItem(), and testReconfigInCommonPool().

{
  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 294 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 299 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 304 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 315 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 320 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 309 of file Registry.cxx.

References Set().

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

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

Definition at line 325 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 330 of file Registry.cxx.

References genie::SetRegistryItem().

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

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

Definition at line 335 of file Registry.cxx.

References genie::SetRegistryItem().

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

void Registry::SetName

(

string

name

)

set the registry name

Definition at line 603 of file Registry.cxx.

References fIsReadOnly, fName, LOG, and pWARN.

Referenced by genie::AlgConfigPool::LoadRegistries().

{
  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 168 of file Registry.cxx.

References fIsReadOnly.

Referenced by genie::GetValueOrUseDefault(), main(), and testReconfigInCommonPool().

{
  fIsReadOnly = false;
}

void Registry::UnLockItem

(

RgKey

key

)

unlocks the registry item

Definition at line 260 of file Registry.cxx.

References HTMLTools::entry(), Exists(), fRegistry, LOG, and pWARN.

{
  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 92 of file Registry.cxx.

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

Member Data Documentation

bool genie::Registry::fInhibitItemLocks

private

Definition at line 183 of file Registry.h.

Referenced by Copy(), InhibitItemLocks(), Init(), ItemLocksAreActive(), Print(), and RestoreItemLocks().

bool genie::Registry::fIsReadOnly

private

is read only?

Definition at line 182 of file Registry.h.

Referenced by Copy(), DeleteEntry(), Init(), IsLocked(), Lock(), Print(), SetName(), and UnLock().

string genie::Registry::fName

private

registry's name

Definition at line 181 of file Registry.h.

Referenced by Copy(), Init(), Name(), and SetName().

RgIMap genie::Registry::fRegistry

private

'key' -> 'value' map

Definition at line 184 of file Registry.h.

Referenced by Append(), Clear(), CloneRegistryItem(), CopyToFolder(), DeleteEntry(), Exists(), FindKeys(), GetH1F(), GetH2F(), GetItemMap(), GetTree(), ItemIsLocal(), ItemIsLocked(), ItemType(), LinkToGlobalDef(), LockItem(), Merge(), NEntries(), OverrideGlobalDef(), Print(), SafeFind(), Set(), and UnLockItem().

---

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

• Framework/Registry/Registry.h
• Framework/Registry/Registry.cxx