DataStore Class Reference

In the store you can park objects that have to be accessed by various modules. More...

#include <DataStore.h>

Collaboration diagram for DataStore:

Classes
class	SwitchableDataStoreContents
	Encapsulates DataStoreContents, but allows transparently switching between different versions ('DataStore IDs'). More...

Public Types
enum	EDurability {   c_Event ,   c_Persistent }
	Durability types. More...
enum	EStoreFlags {   c_WriteOut = 0 ,   c_DontWriteOut = 1 ,   c_ErrorIfAlreadyRegistered = 2 }
	Flags describing behaviours of objects etc. More...
enum	ESearchSide {   c_FromSide ,   c_ToSide ,   c_BothSides }
	Which side of relations should be returned? More...
typedef Belle2::StoreEntry	StoreEntry
	Wraps a stored array/object, stored under unique (name, durability) key.
typedef std::map< std::string, StoreEntry >	StoreEntryMap
	Map for StoreEntries.
typedef StoreEntryMap::iterator	StoreEntryIter
	Iterator for a StoreEntry map.
typedef StoreEntryMap::const_iterator	StoreEntryConstIter
	const_iterator for a StoreEntry map.
typedef std::array< StoreEntryMap, c_NDurabilityTypes >	DataStoreContents
	StoreEntry maps for each durability.

Public Member Functions
bool	registerEntry (const std::string &name, EDurability durability, TClass *objClass, bool array, EStoreFlags storeFlags)
	Register an entry in the DataStore map.
bool	registerRelation (const StoreAccessorBase &fromArray, const StoreAccessorBase &toArray, EDurability durability, EStoreFlags storeFlags, const std::string &namedRelation)
	Register a relation in the DataStore map.
bool	hasRelation (const StoreAccessorBase &fromArray, const StoreAccessorBase &toArray, EDurability durability, const std::string &namedRelation)
	Check for the existence of a relation in the DataStore map.
bool	requireInput (const StoreAccessorBase &accessor)
	Produce ERROR message if no entry of the given type is registered in the DataStore.
bool	requireRelation (const StoreAccessorBase &fromArray, const StoreAccessorBase &toArray, EDurability durability, std::string const &namedRelation)
	Produce ERROR message if no relation of given durability exists between fromArray and toArray (in that direction).
bool	optionalInput (const StoreAccessorBase &accessor)
	Register the given object/array as an optional input.
StoreEntry *	getEntry (const StoreAccessorBase &accessor)
	Check whether an entry with the correct type is registered in the DataStore map and return it.
TObject **	getObject (const StoreAccessorBase &accessor)
	Get a pointer to a pointer of an object in the DataStore.
bool	createObject (TObject *object, bool replace, const StoreAccessorBase &accessor)
	Create a new object/array in the DataStore or add an existing one.
void	replaceData (const StoreAccessorBase &from, const StoreAccessorBase &to)
	For two StoreAccessors of same type, move all data in 'from' into 'to', discarding previous contents of 'to' and leaving 'from' empty.
StoreEntryMap &	getStoreEntryMap (EDurability durability)
	Get a reference to the object/array map.
void	addRelation (const TObject *fromObject, StoreEntry *&fromEntry, int &fromIndex, const TObject *toObject, StoreEntry *&toEntry, int &toIndex, float weight, const std::string &namedRelation)
	Add a relation from an object in a store array to another object in a store array.
RelationVectorBase	getRelationsWith (ESearchSide searchSide, const TObject *object, StoreEntry *&entry, int &index, const TClass *withClass, const std::string &withName, const std::string &namedRelation)
	Get the relations between an object and other objects in a store array.
Belle2::RelationEntry	getRelationWith (ESearchSide searchSide, const TObject *object, StoreEntry *&entry, int &index, const TClass *withClass, const std::string &withName, const std::string &namedRelation)
	Get the first relation between an object and another object in a store array.
bool	findStoreEntry (const TObject *object, StoreEntry *&entry, int &index)
	Find an object in an array in the data store.
std::vector< std::string >	getListOfRelatedArrays (const StoreAccessorBase &array) const
	Returns a list of names of arrays which have registered relations that point to or from 'array'.
std::vector< std::string >	getListOfArrays (const TClass *arrayClass, EDurability durability) const
	Returns a list of names of arrays which are of type (or inherit from) arrayClass.
std::vector< std::string >	getSortedListOfDataStore (EDurability durability) const
	Returns a (sorted) list of all the content of the DataStore (Objs-Arrays-Relations).
void	setInitializeActive (bool active)
	Setter for m_initializeActive.
bool	getInitializeActive () const
	Are we currently initializing modules?
void	invalidateData (EDurability durability)
	Clears all registered StoreEntry objects of a specified durability, invalidating all objects.
void	reset (EDurability durability)
	Frees memory occupied by data store items and removes all objects from the map.
void	reset ()
	Clears contents of the datastore (all durabilities)
DependencyMap &	getDependencyMap ()
	Return map of dependencies between modules.
void	createNewDataStoreID (const std::string &id)
	creates new datastore with given id, copying the registered objects/arrays from the current one.
void	createEmptyDataStoreID (const std::string &id)
	creates empty datastore with given id.
std::string	currentID () const
	returns ID of current DataStore.
void	switchID (const std::string &id)
	switch to DataStore with given ID.
void	copyEntriesTo (const std::string &id, const std::vector< std::string > &entrylist_event={}, bool mergeEntries=false)
	copy entries (not contents) of current DataStore to the DataStore with given ID.
void	copyContentsTo (const std::string &id, const std::vector< std::string > &entrylist_event={})
	copy contents (actual array / object contents) of current DataStore to the DataStore with given ID.
void	mergeContentsTo (const std::string &id, const std::vector< std::string > &entrylist_event={})
	merge contents (actual array / object contents) of current DataStore to the DataStore with given ID.

Static Public Member Functions
static DataStore &	Instance ()
	Instance of singleton Store.
static TClass *	getTClassFromDefaultObjectName (const std::string &objectName)
	Tries to deduce the TClass from a default object name, which is generally the name of the C++ class.
static TClass *	getTClassFromDefaultArrayName (const std::string &arrayName)
	Tries to deduce the TClass from a default array name, which is generally the name of the C++ class with an appended 's'.
static std::string	defaultObjectName (const std::string &classname)
	Return the default storage name for given class name.
static std::string	defaultObjectName (const TClass *t)
	Return the default storage name for an object of the given TClass.
template<class T>
static std::string	defaultObjectName ()
	Return the default storage name for an object of the given type.
static std::string	objectName (const TClass *t, const std::string &name)
	Return the storage name for an object of the given TClass and name.
template<class T>
static std::string	objectName (const std::string &name)
	Return the storage name for an object of the given type and name.
static std::string	defaultArrayName (const std::string &classname)
	Return the default storage name for an given class name.
static std::string	defaultArrayName (const TClass *t)
	Return the default storage name for an array of the given TClass.
template<class T>
static std::string	defaultArrayName ()
	Return the default storage name for an array of the given type.
static std::string	arrayName (const TClass *t, const std::string &name)
	Return the storage name for an object of the given TClass and name.
template<class T>
static std::string	arrayName (const std::string &name)
	Return the storage name for an object of the given type and name.
template<class FROM, class TO>
static std::string	defaultRelationName ()
	Return the default storage name for a relation between the given types.
static std::string	relationName (const std::string &fromName, const std::string &toName, std::string const &namedRelation="")
	Return storage name for a relation between two arrays of the given names.
static bool	optionalRelation (const StoreAccessorBase &fromArray, const StoreAccessorBase &toArray, EDurability durability, std::string const &namedRelation)
	Register the given relation as an optional input.
static void	addRelationFromTo (const TObject *fromObject, const TObject *toObject, float weight=1.0, const std::string &namedRelation="")
	Add a relation from an object in a store array to another object in a store array.
template<class T>
static RelationVector< T >	getRelationsWithObj (const TObject *object, const std::string &name="", const std::string &namedRelation="")
	Get the relations between an object and other objects in a store array.
template<class T>
static T *	getRelated (const TObject *object, const std::string &name="", const std::string &namedRelation="")
	Get the object to or from which another object has a relation.
static std::vector< std::string >	getListOfObjects (const TClass *objClass, EDurability durability)
	Returns a list of names of StoreObjPtr-objects whose class is (or inherits from) objClass.
static std::vector< std::string >	getListOfRelations (EDurability durability)
	Returns a list of names of StoreObjPtr-objects whose class is (or inherits from) RelationContainer.

Static Public Attributes
static const int	c_NDurabilityTypes = 2
	Number of Durability Types.
static bool	s_DoCleanup = false
	Global flag to to decide if we can do normal cleanup.

Private Member Functions
	DataStore ()
	Hidden constructor, as it is a singleton.
	DataStore (const DataStore &)=delete
	no copy constructor
DataStore &	operator= (const DataStore &)=delete
	no assignment operator
	~DataStore ()
	Destructor.
const std::vector< std::string > &	getArrayNames (const std::string &arrayName, const TClass *arrayClass, EDurability durability=c_Event) const
	Returns a vector with the names of store arrays matching the given name and class.

Static Private Member Functions
static void	checkType (const StoreEntry &entry, const StoreAccessorBase &accessor)
	Check whether the given entry and the requested class match; if not, a B2FATAL is raised.
static void	updateRelationsObjectCache (StoreEntry &entry)
	For an array containing RelationsObjects, update index and entry cache for entire contents.

Private Attributes
SwitchableDataStoreContents	m_storeEntryMap
	Maps (name, durability) key to StoreEntry objects.
bool	m_initializeActive
	True if modules are currently being initialized.
const std::regex	m_regexNamedRelationCheck = std::regex("^[a-zA-Z]*$")
	Regular expression to check that no special characters and no white spaces are in the string given for namedRelations.
DependencyMap *	m_dependencyMap
	Collect information about the dependencies between modules.

Detailed Description

In the store you can park objects that have to be accessed by various modules.

Normal users should access the store via StoreAccessorBase-derived classes like StoreObjPtr or StoreArray.

Nomenclature:

• Entry: unique (name, durability) key that can store an array/object, see StoreEntry. Entries are created using registerEntry().
• Object: In this context, can mean an array or object stored in an entry, see e.g. createObject(), getObject()
• Durability: defines duration that objects are valid, see DataStore::EDurability.

See also

EDurability StoreObjPtr StoreArray RelationsObject

Definition at line 51 of file DataStore.h.

Member Typedef Documentation

DataStoreContents

typedef std::array<StoreEntryMap, c_NDurabilityTypes> DataStoreContents

StoreEntry maps for each durability.

Definition at line 90 of file DataStore.h.

StoreEntry

typedef Belle2::StoreEntry StoreEntry

Wraps a stored array/object, stored under unique (name, durability) key.

Definition at line 84 of file DataStore.h.

StoreEntryConstIter

typedef StoreEntryMap::const_iterator StoreEntryConstIter

const_iterator for a StoreEntry map.

Definition at line 89 of file DataStore.h.

StoreEntryIter

typedef StoreEntryMap::iterator StoreEntryIter

Iterator for a StoreEntry map.

Definition at line 88 of file DataStore.h.

StoreEntryMap

typedef std::map<std::string, StoreEntry> StoreEntryMap

Map for StoreEntries.

Definition at line 87 of file DataStore.h.

Member Enumeration Documentation

EDurability

enum EDurability

Durability types.

Defines how long an object should be valid.

Enumerator
c_Event	Different object in each event, all objects/arrays are invalidated after event() function has been called on last module in path.
c_Persistent	Object is available during entire execution time. Objects are never invalidated and are accessible even after process(Path) returns.

Definition at line 58 of file DataStore.h.

                     {
      c_Event,     
      c_Persistent 
    };

ESearchSide

enum ESearchSide

Which side of relations should be returned?

Enumerator
c_FromSide	Return relations/objects pointed from (to a given object).
c_ToSide	Return relations/objects pointed to (from a given object).
c_BothSides	Combination of c_FromSide and c_ToSide.

Definition at line 76 of file DataStore.h.

                     {
      c_FromSide, 
      c_ToSide,   
      c_BothSides 
    };

EStoreFlags

enum EStoreFlags

Flags describing behaviours of objects etc.

Bitwise operators (|, &, etc.) are provided via ADD_BITMASK_OPERATORS.

Enumerator
c_WriteOut	Object/array should be saved by output modules. (default)
c_DontWriteOut	Object/array should be NOT saved by output modules. Can be overridden using the 'branchNames' parameter of RootOutput.
c_ErrorIfAlreadyRegistered	If the object/array was already registered, produce an error (aborting initialisation).

Definition at line 69 of file DataStore.h.

                     {
      c_WriteOut = 0,                
      c_DontWriteOut = 1,            
      c_ErrorIfAlreadyRegistered = 2,
    };

Constructor & Destructor Documentation

DataStore()

DataStore ( )

explicitprivate

Hidden constructor, as it is a singleton.

Definition at line 60 of file DataStore.cc.

                     : m_initializeActive(true), m_dependencyMap(new DependencyMap)
{
}

~DataStore()

~DataStore ( )

private

Destructor.

Definition at line 64 of file DataStore.cc.

{
  if (s_DoCleanup) {
    //release all memory in data store
    reset();
  }
  delete m_dependencyMap;
}

Member Function Documentation

addRelation()

void addRelation	(	const TObject *	fromObject,
		StoreEntry *&	fromEntry,
		int &	fromIndex,
		const TObject *	toObject,
		StoreEntry *&	toEntry,
		int &	toIndex,
		float	weight,
		const std::string &	namedRelation )

Add a relation from an object in a store array to another object in a store array.

Parameters

fromObject	Pointer to the object from which the relation points.
fromEntry	Data store entry that contains the fromObject. Used for caching. Will be set if NULL.
fromIndex	Index in TClonesArray that contains the fromObject. Used for caching. Will be set if < 0.
toObject	Pointer to the object to which the relation points.
toEntry	Data store entry that contains the toObject. Used for caching. Will be set if NULL.
toIndex	Index in TClonesArray that contains the toObject. Used for caching. Will be set if < 0.
weight	Weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 490 of file DataStore.cc.

{
  if (!fromObject or !toObject)
    return;
 
  // get entry from which the relation points
  if (!findStoreEntry(fromObject, fromEntry, fromIndex)) {
    B2FATAL("Couldn't find from-side entry for relation between " << fromObject->ClassName() << " and " << toObject->ClassName() <<
            ". Please make sure the object is part of a StoreArray before adding a relation.");
  }
 
  // get entry to which the relation points
  if (!findStoreEntry(toObject, toEntry, toIndex)) {
    B2FATAL("Couldn't find to-side entry for relation between " << fromObject->ClassName() << " and " << toObject->ClassName() <<
            ". Please make sure the object is part of a StoreArray before adding a relation.");
  }
 
  // get the relations from -> to
  const string& relationsName = relationName(fromEntry->name, toEntry->name, namedRelation);
  const StoreEntryIter& it = m_storeEntryMap[c_Event].find(relationsName);
  if (it == m_storeEntryMap[c_Event].end()) {
    B2FATAL("No relation '" << relationsName <<
            "' found. Please register it (using StoreArray::registerRelationTo()) before trying to add relations.");
  }
  StoreEntry* entry = &(it->second);
 
  // auto create relations if needed (both if null pointer, or uninitialised object read from TTree)
  if (!entry->ptr)
    entry->recreate();
  auto* relContainer = static_cast<RelationContainer*>(entry->ptr);
  if (relContainer->isDefaultConstructed()) {
    relContainer->setFromName(fromEntry->name);
    relContainer->setFromDurability(c_Event);
    relContainer->setToName(toEntry->name);
    relContainer->setToDurability(c_Event);
  }
 
  // add relation
  TClonesArray& relations = relContainer->elements();
  new (relations.AddrAt(relations.GetLast() + 1)) RelationElement(fromIndex, toIndex, weight);
 
  std::shared_ptr<RelationIndexContainer<TObject, TObject>> relIndex =
                                                           RelationIndexManager::Instance().getIndexIfExists<TObject, TObject>(relationsName, c_Event);
  if (relIndex) {
    // add it to index (so we avoid expensive rebuilding later)
    relIndex->index().emplace(fromIndex, toIndex, fromObject, toObject, weight);
  } else {
    //mark for rebuilding later on
    relContainer->setModified(true);
  }
}

addRelationFromTo()

static void addRelationFromTo ( const TObject * fromObject, const TObject * toObject, float weight = 1.0, const std::string & namedRelation = "" )

inlinestatic

Add a relation from an object in a store array to another object in a store array.

Note

If possible, use RelationsObject members instead, as they allow more efficient caching. Currently this should only be necessary if fromObject is of type genfit::...

See also

RelationsObject::addRelationTo

Parameters

fromObject	Pointer to the object from which the relation points.
toObject	Pointer to the object to which the relation points.
weight	Weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 387 of file DataStore.h.

    {
      DataStore::StoreEntry* fromEntry = nullptr;
      int fromIndex = -1;
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      Instance().addRelation(fromObject, fromEntry, fromIndex, toObject, toEntry, toIndex, weight, namedRelation);
    }

arrayName() [1/2]

template<class T>

static std::string arrayName ( const std::string & name )

inlinestatic

Return the storage name for an object of the given type and name.

Definition at line 167 of file DataStore.h.

    {
      return ((name.empty()) ? defaultArrayName<T>() : name);
    }

arrayName() [2/2]

std::string arrayName ( const TClass * t, const std::string & name )

static

Return the storage name for an object of the given TClass and name.

Definition at line 163 of file DataStore.cc.

{
  return ((name.empty()) ? defaultArrayName(t) : name);
}

checkType()

void checkType ( const StoreEntry & entry, const StoreAccessorBase & accessor )

staticprivate

Check whether the given entry and the requested class match; if not, a B2FATAL is raised.

Name and durability are not checked.

Parameters

entry	The existing DataStore entry.
accessor	Encapsulates name, durability, and type

Definition at line 169 of file DataStore.cc.

{
  // Check whether the existing entry and the requested object are both arrays or both single objects
  const char* entryType = (entry.isArray) ? "array" : "object";
  if (entry.isArray != accessor.isArray()) {
    B2FATAL("Existing entry '" << entry.name << "' is an " << entryType << " and the requested one an " << ((
              accessor.isArray()) ? "array" : "object"));
  }
 
  // Check whether the existing entry has the same type
  const TClass* entryClass = entry.objClass;
  if (!entryClass->InheritsFrom(accessor.getClass())) {
    B2FATAL("Existing " << accessor.readableName() << " of type " << entryClass->GetName() << " doesn't match requested type " <<
            accessor.getClass()->GetName());
  }
}

copyContentsTo()

void copyContentsTo	(	const std::string &	id,
		const std::vector< std::string > &	entrylist_event = {} )

copy contents (actual array / object contents) of current DataStore to the DataStore with given ID.

Definition at line 808 of file DataStore.cc.

{
  m_storeEntryMap.copyContentsTo(id, entrylist_event);
}

copyEntriesTo()

void copyEntriesTo	(	const std::string &	id,
		const std::vector< std::string > &	entrylist_event = {},
		bool	mergeEntries = false )

copy entries (not contents) of current DataStore to the DataStore with given ID.

Definition at line 803 of file DataStore.cc.

{
  m_storeEntryMap.copyEntriesTo(id, entrylist_event, mergeEntries);
}

createEmptyDataStoreID()

void createEmptyDataStoreID

(

const std::string &

id

)

creates empty datastore with given id.

Definition at line 782 of file DataStore.cc.

{
  m_storeEntryMap.createEmptyDataStoreID(id);
}

createNewDataStoreID()

void createNewDataStoreID

(

const std::string &

id

)

creates new datastore with given id, copying the registered objects/arrays from the current one.

Definition at line 777 of file DataStore.cc.

{
  m_storeEntryMap.createNewDataStoreID(id);
}

createObject()

bool createObject	(	TObject *	object,
		bool	replace,
		const StoreAccessorBase &	accessor )

Create a new object/array in the DataStore or add an existing one.

A matching map entry must already exist. Otherwise an error will be generated.

Parameters

object	Pointer to the object that should be stored. If 0, a new default object is created.
replace	If an object already exists, it will be replaced if this is true. If false, an error will be printed.
accessor	Encapsulates name, durability, and type

Returns

Whether the object was successfully inserted/created

Definition at line 314 of file DataStore.cc.

{
  StoreEntry* entry = getEntry(accessor);
  if (!entry) {
    B2ERROR("No " << accessor.readableName() <<
            " exists in the DataStore, did you forget to register it in your Module's initialize() function? Note: direct accesses to it will crash!");
    return false;
  }
 
  if (entry->ptr && !replace && object != entry->object) {
    B2ERROR("An " << accessor.readableName() << " was already created in the DataStore.");
    return false;
  }
 
  if (object) {
    if (object != entry->object) {
      delete entry->object;
      entry->object = object;
    }
    entry->ptr = entry->object;
  } else {
    entry->recreate();
  }
 
  return true;
}

currentID()

std::string currentID

(

)

const

returns ID of current DataStore.

Definition at line 787 of file DataStore.cc.

{
  return m_storeEntryMap.currentID();
}

defaultArrayName() [1/3]

template<class T>

static std::string defaultArrayName ( )

inlinestatic

Return the default storage name for an array of the given type.

Definition at line 157 of file DataStore.h.

    {
      const static std::string s = defaultArrayName(defaultObjectName<T>());
      return s;
    }

defaultArrayName() [2/3]

static std::string defaultArrayName ( const std::string & classname )

inlinestatic

Return the default storage name for an given class name.

Definition at line 143 of file DataStore.h.

    {
      const std::string& objName = defaultObjectName(classname);
      std::string s;
      s.reserve(objName.length() + 1);
      s += objName;
      s += 's';
      return s;
    }

defaultArrayName() [3/3]

std::string defaultArrayName ( const TClass * t )

static

Return the default storage name for an array of the given TClass.

Definition at line 156 of file DataStore.cc.

{
  const std::string s = defaultArrayName(defaultObjectName(t));
  return s;
}

defaultObjectName() [1/3]

template<class T>

static std::string defaultObjectName ( )

inlinestatic

Return the default storage name for an object of the given type.

Definition at line 127 of file DataStore.h.

    {
      const static std::string s = defaultObjectName(T::Class_Name());
      return s;
    }

defaultObjectName() [2/3]

std::string defaultObjectName ( const std::string & classname )

static

Return the default storage name for given class name.

Definition at line 127 of file DataStore.cc.

{
  const static string gfclass = "genfit::Track";
  const static string gfobjectname = "GF2Track";
  if (classname == gfclass)
    return gfobjectname;
  //Strip qualifiers like namespaces
  size_t colon = classname.rfind(':');
  if (colon != std::string::npos) {
    return classname.substr(colon + 1);
  }
  return classname;
}

defaultObjectName() [3/3]

std::string defaultObjectName ( const TClass * t )

static

Return the default storage name for an object of the given TClass.

Definition at line 142 of file DataStore.cc.

{
  B2ASSERT("Cannot deduce default object name from null pointer TClass", t);
  const std::string s = defaultObjectName(t->GetName());
  return s;
}

defaultRelationName()

template<class FROM, class TO>

static std::string defaultRelationName ( )

inlinestatic

Return the default storage name for a relation between the given types.

Definition at line 173 of file DataStore.h.

    {
      const static std::string s = relationName(defaultArrayName<FROM>(), defaultArrayName<TO>());
      return s;
    }

findStoreEntry()

bool findStoreEntry	(	const TObject *	object,
		DataStore::StoreEntry *&	entry,
		int &	index )

Find an object in an array in the data store.

entry/index are used to return the found array and index, should be set to NULL and -1, or some cached values (will be checked).

Given non-NULL entry and index>=0, this function returns immediately if the object is found at the given position.

Parameters

object	Pointer to the object.
entry	The DataStore entry that contains the object.
index	The index of the object in the array.

Returns

True if the object was found in the data store

Definition at line 396 of file DataStore.cc.

{
  if (!entry or index < 0) {
    //usually entry/index should be passed for RelationsObject,
    //but there are exceptions -> let's check again
    const auto* relObj = dynamic_cast<const RelationsObject*>(object);
    if (relObj) {
      entry = relObj->m_cacheDataStoreEntry;
      index = relObj->m_cacheArrayIndex;
    }
  }
  // check whether the cached information is (still) valid
  if (entry && entry->ptr && (index >= 0)) {
    const TClonesArray* array = static_cast<TClonesArray*>(entry->ptr);
    if (array->At(index) == object) return true;
    B2INFO("findStoreEntry: cached index invalid, probably harmless but odd : " << entry->name << " idx " << index);
    index = array->IndexOf(object);
    if (index >= 0) return true;
    B2INFO("findStoreEntry: cached entry was also wrong");
  }
  entry = nullptr;
  index = -1;
 
  //searching for nullptr should be safe
  if (!object)
    return false;
 
  // search for the object and set the entry and index
  const TClass* objectClass = object->IsA();
  for (auto& mapEntry : m_storeEntryMap[c_Event]) {
    if (mapEntry.second.ptr && mapEntry.second.isArray) {
      const TClass* arrayClass = mapEntry.second.objClass;
      if (arrayClass != objectClass)
        continue;
 
      const TClonesArray* array = static_cast<TClonesArray*>(mapEntry.second.ptr);
      if (object == array->Last()) {
        //quickly find entry if it's at the end of the array
        index = array->GetLast();
      } else {
        if (arrayClass->InheritsFrom(RelationsObject::Class())) {
          //update cache for entire array
          updateRelationsObjectCache(mapEntry.second);
 
          //if found, m_cacheArrayIndex is now correct, otherwise still -1
          StoreEntry* objEntry = static_cast<const RelationsObject*>(object)->m_cacheDataStoreEntry;
          index = static_cast<const RelationsObject*>(object)->m_cacheArrayIndex;
          if (index >= 0 and objEntry) {
            //if the cache of 'object' is  filled, make sure to also set entry!
            entry = objEntry;
            return true;
          }
        } else {
          //not a RelationsObject, so no caching
          index = array->IndexOf(object);
        }
      }
 
      if (index >= 0) {
        entry = &mapEntry.second;
        return true;
      }
    }
  }
  return false;
}

getArrayNames()

const std::vector< std::string > & getArrayNames ( const std::string & arrayName, const TClass * arrayClass, EDurability durability = c_Event ) const

private

Returns a vector with the names of store arrays matching the given name and class.

Note that the returned reference is only valid until the next call.

Parameters

arrayName	A given array name, the special string "ALL" for all arrays deriving from the given class, or an empty string for the default array name.
arrayClass	The class of the array(s).
durability	Decide with which durability map you want to perform the requested action.

Definition at line 463 of file DataStore.cc.

{
  static vector<string> arrayNames;
  arrayNames.clear();
  if (name.empty()) {
    static std::unordered_map<const TClass*, string> classToArrayName;
    const auto& it = classToArrayName.find(arrayClass);
    if (it != classToArrayName.end()) {
      arrayNames.emplace_back(it->second);
    } else {
      const std::string& result = defaultArrayName(arrayClass->GetName());
      classToArrayName[arrayClass] = result;
      arrayNames.emplace_back(result);
    }
  } else if (name == "ALL") {
    for (auto& mapEntry : m_storeEntryMap[durability]) {
      if (mapEntry.second.object and mapEntry.second.isArray and mapEntry.second.objClass->InheritsFrom(arrayClass)) {
        arrayNames.emplace_back(mapEntry.second.name);
      }
    }
  } else {
    arrayNames.emplace_back(name);
  }
  return arrayNames;
}

getDependencyMap()

DependencyMap & getDependencyMap ( )

inline

Return map of dependencies between modules.

Definition at line 524 of file DataStore.h.

{ return *m_dependencyMap; }

getEntry()

DataStore::StoreEntry * getEntry

(

const StoreAccessorBase &

accessor

)

Check whether an entry with the correct type is registered in the DataStore map and return it.

If the map of requested durability already contains an object under the key name with a DIFFERENT type than the given type one, an error will be reported.

Parameters

accessor

Encapsulates name, durability, and type

Returns

StoreEntry, or NULL if not found

Definition at line 291 of file DataStore.cc.

{
  const auto& it = m_storeEntryMap[accessor.getDurability()].find(accessor.getName());
 
  if (it != m_storeEntryMap[accessor.getDurability()].end()) {
    checkType((it->second), accessor);
    return &(it->second);
  } else {
    return nullptr;
  }
}

getInitializeActive()

bool getInitializeActive ( ) const

inline

Are we currently initializing modules?

Definition at line 502 of file DataStore.h.

{ return m_initializeActive; }

getListOfArrays()

std::vector< std::string > getListOfArrays	(	const TClass *	arrayClass,
		EDurability	durability ) const

Returns a list of names of arrays which are of type (or inherit from) arrayClass.

Definition at line 664 of file DataStore.cc.

{
  return getArrayNames("ALL", arrayClass, durability);
}

getListOfObjects()

std::vector< std::string > getListOfObjects ( const TClass * objClass, EDurability durability )

static

Returns a list of names of StoreObjPtr-objects whose class is (or inherits from) objClass.

(this does NOT include the internal RelationContainer objects.)

Definition at line 669 of file DataStore.cc.

{
  vector<string> list;
  const DataStore::StoreEntryMap& map = DataStore::Instance().getStoreEntryMap(DataStore::EDurability(durability));
  for (const auto& entrypair : map) {
    if (!entrypair.second.isArray) {
      const TObject* obj = entrypair.second.object;
      if (dynamic_cast<const RelationContainer*>(obj))
        continue; //ignore relations in list
 
      if (obj and obj->IsA()->InheritsFrom(objClass))
        list.emplace_back(entrypair.first);
    }
  }
  return list;
}

getListOfRelatedArrays()

std::vector< std::string > getListOfRelatedArrays

(

const StoreAccessorBase &

array

)

const

Returns a list of names of arrays which have registered relations that point to or from 'array'.

This may be useful for internal purposes when modifying array contents.

Definition at line 638 of file DataStore.cc.

{
  std::vector<std::string> arrays;
  if (!array.isArray()) {
    B2ERROR("getListOfRelatedArrays(): " << array.readableName() << " is not an array!");
    return arrays;
  }
 
  //loop over all arrays
  EDurability durability = array.getDurability();
  for (const auto& mapEntry : m_storeEntryMap[durability]) {
    if (mapEntry.second.isArray) {
      const std::string& name = mapEntry.second.name;
 
      //check both from & to 'array'
      for (int searchSide = 0; searchSide < c_BothSides; searchSide++) {
        const string& relationsName = (searchSide == c_ToSide) ? relationName(array.getName(), name) : relationName(name, array.getName());
        const StoreEntryConstIter& it = m_storeEntryMap[durability].find(relationsName);
        if (it != m_storeEntryMap[durability].end())
          arrays.emplace_back(name);
      }
    }
  }
 
  return arrays;
}

getListOfRelations()

std::vector< std::string > getListOfRelations ( EDurability durability )

static

Returns a list of names of StoreObjPtr-objects whose class is (or inherits from) RelationContainer.

Definition at line 686 of file DataStore.cc.

{
  vector<string> list;
  const DataStore::StoreEntryMap& map = DataStore::Instance().getStoreEntryMap(DataStore::EDurability(durability));
  for (const auto& entrypair : map) {
    if (!entrypair.second.isArray) {
      const TObject* obj = entrypair.second.object;
      if (dynamic_cast<const RelationContainer*>(obj))
        list.emplace_back(entrypair.first);
 
    }
  }
  return list;
}

getObject()

TObject ** getObject

(

const StoreAccessorBase &

accessor

)

Get a pointer to a pointer of an object in the DataStore.

If the map of requested durability already contains an object under the key name with a DIFFERENT type than the given type one, an error will be reported.

Parameters

accessor

Encapsulates name, durability, and type

Returns

Pointer to pointer to object, NULL if none exists

Definition at line 304 of file DataStore.cc.

{
  StoreEntry* entry = getEntry(accessor);
  if (!entry) {
    return nullptr;
  }
  return &(entry->ptr);
}

getRelated()

template<class T>

static T * getRelated ( const TObject * object, const std::string & name = "", const std::string & namedRelation = "" )

inlinestatic

Get the object to or from which another object has a relation.

Note

If possible, use RelationsObject members instead, as they allow more efficient caching. Currently this should only be necessary if type(object) == genfit::..

Parameters

object

Pointer to the object to or from which the relation points.

Template Parameters

T	The class of objects to or from which the relation points.

Parameters

name	The name of the store array to or from which the relation points. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

The related object or a null pointer.

Definition at line 432 of file DataStore.h.

    {
      if (!object) return nullptr;
      StoreEntry* storeEntry = nullptr;
      int index = -1;
      return static_cast<T*>(DataStore::Instance().getRelationWith(c_BothSides, object, storeEntry, index, T::Class(), name,
                             namedRelation).object);
    }

getRelationsWith()

RelationVectorBase getRelationsWith	(	ESearchSide	searchSide,
		const TObject *	object,
		DataStore::StoreEntry *&	entry,
		int &	index,
		const TClass *	withClass,
		const std::string &	withName,
		const std::string &	namedRelation )

Get the relations between an object and other objects in a store array.

Parameters

searchSide	Search objects of type withClass on this side of relations (with 'object' on the other side).
object	Pointer to the object from or to which the relations point.
entry	Data store entry that contains the object. Used for caching. Will be set if 0.
index	Index in TClonesArray that contains the object. Used for caching. Will be set if < 0.
withClass	Class of the objects to or from which the relations point.
withName	The name of the store array to or from which the relations point. If empty the default store array name for withClass will be used. If the special name "ALL" is given all store arrays containing object of type withClass are considered.
namedRelation	Additional name for the relation, or "" for the default naming. If withName is "ALL", the namedRelation parameter is ignored and all related objects are returned.

Returns

Vector of relation entry objects (not type-safe).

Definition at line 543 of file DataStore.cc.

{
  if (searchSide == c_BothSides) {
    auto result = getRelationsWith(c_ToSide, object, entry, index, withClass, withName, namedRelation);
    const auto& fromResult = getRelationsWith(c_FromSide, object, entry, index, withClass, withName, namedRelation);
    result.add(fromResult);
    return result;
  }
 
  std::vector<RelationEntry> result;
 
  // get StoreEntry for 'object'
  if (!findStoreEntry(object, entry, index)) return RelationVectorBase();
 
  // get names of store arrays to search
  const std::vector<string>& names = getArrayNames(withName, withClass);
  vector<string> relationNames;
 
  // loop over found store arrays
  for (const std::string& name : names) {
    // get the relations from -> to
    const string& relationsName = (searchSide == c_ToSide) ? relationName(entry->name, name, namedRelation) : relationName(name,
                                  entry->name, namedRelation);
    RelationIndex<TObject, TObject> relIndex(relationsName, c_Event);
    if (!relIndex)
      continue;
 
    const size_t prevsize = result.size();
 
    //get relations with object
    if (searchSide == c_ToSide) {
      for (const auto& rel : relIndex.getElementsFrom(object)) {
        auto* const toObject = const_cast<TObject*>(rel.to);
        if (toObject)
          result.emplace_back(toObject, rel.weight);
      }
    } else {
      for (const auto& rel : relIndex.getElementsTo(object)) {
        auto* const fromObject = const_cast<TObject*>(rel.from);
        if (fromObject)
          result.emplace_back(fromObject, rel.weight);
      }
    }
 
    if (result.size() != prevsize)
      relationNames.push_back(relationsName);
  }
 
  return RelationVectorBase(entry->name, index, result, relationNames);
}

getRelationsWithObj()

template<class T>

static RelationVector< T > getRelationsWithObj ( const TObject * object, const std::string & name = "", const std::string & namedRelation = "" )

inlinestatic

Get the relations between an object and other objects in a store array.

Relations in both directions are returned.

Note

Using this function should only be necessary if type(object) == genfit::.... If possible, use RelationsObject members instead, as they allow more efficient caching.

See also

RelationsObject::getRelationsWith

Parameters

object

Pointer to the object from or to which the relations point.

Template Parameters

T	Class of the objects to or from which the relations point.

Parameters

name	The name of the store array to or from which the relations point. If empty the default store array name for withClass will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

Vector of relation entry objects.

Definition at line 412 of file DataStore.h.

    {
      StoreEntry* storeEntry = nullptr;
      int index = -1;
      return RelationVector<T>(Instance().getRelationsWith(c_BothSides, object, storeEntry, index, T::Class(), name, namedRelation));
    }

getRelationWith()

RelationEntry getRelationWith	(	ESearchSide	searchSide,
		const TObject *	object,
		DataStore::StoreEntry *&	entry,
		int &	index,
		const TClass *	withClass,
		const std::string &	withName,
		const std::string &	namedRelation )

Get the first relation between an object and another object in a store array.

Parameters

searchSide	Search objects of type withClass on this side of relations (with 'object' on the other side).
object	Pointer to the object from or to which the relation points.
entry	Data store entry that contains the object. Used for caching. Will be set if 0.
index	Index in TClonesArray that contains the object. Used for caching. Will be set if < 0.
withClass	Class of the objects to or from which the relation points.
withName	The name of the store array to or from which the relation points. If empty the default store array name for withClass will be used. If the special name "ALL" is given all store arrays containing object of type withClass are considered.
namedRelation	Additional name for the relation, or "" for the default naming. If withName is "ALL", the namedRelation parameter is ignored and all related objects are returned.

Returns

The entry of the first related object.

Definition at line 595 of file DataStore.cc.

{
  if (searchSide == c_BothSides) {
    RelationEntry result = getRelationWith(c_ToSide, object, entry, index, withClass, withName, namedRelation);
    if (!result.object) {
      result = getRelationWith(c_FromSide, object, entry, index, withClass, withName, namedRelation);
    }
    return result;
  }
 
  // get StoreEntry for 'object'
  if (!findStoreEntry(object, entry, index)) return RelationEntry(nullptr);
 
  // get names of store arrays to search
  const std::vector<string>& names = getArrayNames(withName, withClass);
 
  // loop over found store arrays
  for (const std::string& name : names) {
    // get the relations from -> to
    const string& relationsName = (searchSide == c_ToSide) ? relationName(entry->name, name, namedRelation) : relationName(name,
                                  entry->name, namedRelation);
    RelationIndex<TObject, TObject> relIndex(relationsName, c_Event);
    if (!relIndex)
      continue;
 
    // get first element
    if (searchSide == c_ToSide) {
      const RelationIndex<TObject, TObject>::Element* element = relIndex.getFirstElementFrom(object);
      if (element && element->to) {
        return RelationEntry(const_cast<TObject*>(element->to), element->weight);
      }
    } else {
      const RelationIndex<TObject, TObject>::Element* element = relIndex.getFirstElementTo(object);
      if (element && element->from) {
        return RelationEntry(const_cast<TObject*>(element->from), element->weight);
      }
    }
  }
 
  return RelationEntry(nullptr);
}

getSortedListOfDataStore()

std::vector< std::string > getSortedListOfDataStore

(

EDurability

durability

)

const

Returns a (sorted) list of all the content of the DataStore (Objs-Arrays-Relations).

Definition at line 701 of file DataStore.cc.

{
  std::vector<string> list;
  std::vector<std::string> mergeContent = getListOfObjects(TObject::Class(), durability);
  list.insert(std::end(list), std::begin(mergeContent), std::end(mergeContent));
  mergeContent = getListOfArrays(TObject::Class(), durability);
  list.insert(std::end(list), std::begin(mergeContent), std::end(mergeContent));
  mergeContent = getListOfRelations(durability);
  list.insert(std::end(list), std::begin(mergeContent), std::end(mergeContent));
  return list;
}

getStoreEntryMap()

StoreEntryMap & getStoreEntryMap ( EDurability durability )

inline

Get a reference to the object/array map.

This is intended to be used for input/output or other framework-internal modules.

Definition at line 325 of file DataStore.h.

{ return m_storeEntryMap[durability]; }

getTClassFromDefaultArrayName()

TClass * getTClassFromDefaultArrayName ( const std::string & arrayName )

static

Tries to deduce the TClass from a default array name, which is generally the name of the C++ class with an appended 's'.

The namespace qualification Belle2:: can be omitted

Definition at line 115 of file DataStore.cc.

{
  if (arrayName.empty()) {
    return nullptr;
  } else if ('s' == arrayName.back()) {
    std::string objectNameStr = arrayName.substr(0, arrayName.size() - 1);
    return getTClassFromDefaultObjectName(objectNameStr);
  } else {
    return nullptr;
  }
}

getTClassFromDefaultObjectName()

TClass * getTClassFromDefaultObjectName ( const std::string & objectName )

static

Tries to deduce the TClass from a default object name, which is generally the name of the C++ class.

The namespace qualification Belle2:: can be omitted.

Definition at line 104 of file DataStore.cc.

{
  // First look for an name without the namespace Belle2::
  TClass* cl = TClass::GetClass(("Belle2::" + objectName).c_str());
  if (not cl) {
    // If this fails look for a name that already has the full namespace.
    cl = TClass::GetClass(objectName.c_str());
  }
  return cl;
}

hasRelation()

bool hasRelation	(	const StoreAccessorBase &	fromArray,
		const StoreAccessorBase &	toArray,
		EDurability	durability,
		const std::string &	namedRelation )

Check for the existence of a relation in the DataStore map.

Parameters

fromArray	Origin of the relation
toArray	Target of the relation
durability	Decide with which durability map you want to perform the requested action.
namedRelation	Additional name for the relation, or "" for the default naming.

Returns

True if there is a registered relation.

See also

DependencyMap

Definition at line 268 of file DataStore.cc.

{
  // check that the input makes sense
  if (!fromArray.isArray())
    B2FATAL(fromArray.readableName() << " is not an array!");
  if (!toArray.isArray())
    B2FATAL(toArray.readableName() << " is not an array!");
 
  // check the the namedRelation only contains regular characters
  if (!std::regex_match(namedRelation, m_regexNamedRelationCheck))
    B2FATAL("Named Relations can only contain alphabetic characters, given was: " << namedRelation);
 
  // get the internal relation name from the name provided
  const std::string& realname = relationName(fromArray.getName(), toArray.getName(), namedRelation);
 
  // check whether the map entry exists
  const auto& it = m_storeEntryMap[durability].find(realname);
  if (it != m_storeEntryMap[durability].end()) return true;
 
  return false;
}

Instance()

DataStore & Instance ( )

static

Instance of singleton Store.

This method is used to access the DataStore directly. It is used internally in the Store accessor classes.

Definition at line 53 of file DataStore.cc.

{
  static DataStore instance;
  return instance;
}

invalidateData()

void invalidateData

(

EDurability

durability

)

Clears all registered StoreEntry objects of a specified durability, invalidating all objects.

Called by the framework once the given durability is over. Users should usually not use this function without a good reason.

Definition at line 713 of file DataStore.cc.

{
  B2DEBUG(100, "Invalidating objects for durability " << durability);
  m_storeEntryMap.invalidateData(durability);
  RelationIndexManager::Instance().clear();
}

mergeContentsTo()

void mergeContentsTo	(	const std::string &	id,
		const std::vector< std::string > &	entrylist_event = {} )

merge contents (actual array / object contents) of current DataStore to the DataStore with given ID.

Definition at line 813 of file DataStore.cc.

{
  m_storeEntryMap.mergeContentsTo(id, entrylist_event);
}

objectName() [1/2]

template<class T>

static std::string objectName ( const std::string & name )

inlinestatic

Return the storage name for an object of the given type and name.

Definition at line 137 of file DataStore.h.

    {
      return ((name.empty()) ? defaultObjectName<T>() : name);
    }

objectName() [2/2]

std::string objectName ( const TClass * t, const std::string & name )

static

Return the storage name for an object of the given TClass and name.

Definition at line 150 of file DataStore.cc.

{
  return ((name.empty()) ? defaultObjectName(t) : name);
}

optionalInput()

bool optionalInput

(

const StoreAccessorBase &

accessor

)

Register the given object/array as an optional input.

Mainly useful for creating diagrams of module inputs and outputs.

Parameters

accessor

Encapsulates name, durability, and type

Returns

True if the requested object exists.

See also

DependencyMap

Definition at line 737 of file DataStore.cc.

{
  if (m_initializeActive) {
    m_dependencyMap->getCurrentModuleInfo().addEntry(accessor.getName(), DependencyMap::c_OptionalInput,
                                                     (accessor.getClass() == RelationContainer::Class()));
  }
 
  return (getEntry(accessor) != nullptr);
}

optionalRelation()

bool optionalRelation ( const StoreAccessorBase & fromArray, const StoreAccessorBase & toArray, EDurability durability, std::string const & namedRelation )

static

Register the given relation as an optional input.

Mainly useful for creating diagrams of module inputs and outputs.

Parameters

fromArray	Origin of the relation
toArray	Target of the relation
durability	Decide with which durability map you want to perform the requested action.
namedRelation	Additional name for the relation, or "" for the default naming1

Returns

True if the requested object exists.

See also

DependencyMap

Definition at line 764 of file DataStore.cc.

{
  if (!fromArray.isArray())
    B2FATAL(fromArray.readableName() << " is not an array!");
  if (!toArray.isArray())
    B2FATAL(toArray.readableName() << " is not an array!");
 
  const std::string& relName = relationName(fromArray.getName(), toArray.getName(), namedRelation);
  return DataStore::Instance().optionalInput(StoreAccessorBase(relName, durability, RelationContainer::Class(), false));
}

registerEntry()

bool registerEntry	(	const std::string &	name,
		EDurability	durability,
		TClass *	objClass,
		bool	array,
		EStoreFlags	storeFlags )

Register an entry in the DataStore map.

If the map of requested durability already contains an object under the key name with a DIFFERENT type than the given type, an error will be reported.
Otherwise a new map slot is created. This must be called in the initialization phase. Otherwise an error is returned.

Parameters

name	Name under which you want to save the object in the DataStore.
durability	Decide with which durability map you want to perform the requested action.
objClass	The class of the object.
array	Whether it is a TClonesArray or not.
storeFlags	ORed combination of DataStore::EStoreFlags.

Returns

True if the registration succeeded.

See also

DependencyMap

Definition at line 187 of file DataStore.cc.

{
  const StoreAccessorBase accessor(name, durability, objClass, array);
  // Check whether this method is called in the initialization phase
  if (!m_initializeActive) {
    B2ERROR("Attempt to register " << accessor.readableName() <<
            " outside of the initialization phase. Please move calls to registerInDataStore() into your Module's initialize() function.");
    return false;
  }
  const bool dontwriteout = storeFlags & c_DontWriteOut;
 
  //add to current module's outputs
  m_dependencyMap->getCurrentModuleInfo().addEntry(name, DependencyMap::c_Output, (objClass == RelationContainer::Class()));
 
  // Check whether the map entry already exists
  const auto& it = m_storeEntryMap[durability].find(name);
  if (it != m_storeEntryMap[durability].end()) {
    StoreEntry& entry = it->second;
 
    // Complain about existing entry
    if (storeFlags & c_ErrorIfAlreadyRegistered) {
      B2ERROR("An " << accessor.readableName() << " of type " << entry.object->ClassName() <<
              " was already registered before. (Multiple calls to registerInDataStore() are fine if the c_ErrorIfAlreadyRegistered flag is not set. For objects you will want to make sure that you don't discard existing data from other modules in that case.");
      return false;
    }
 
    // Check whether the types match
    checkType(entry, accessor);
 
    // Check whether the persistency type matches
    if (entry.dontWriteOut != dontwriteout) {
      B2WARNING("Existing " << accessor.readableName() << " has different persistency type than requested. Changing to " <<
                (dontwriteout ? "c_DontWriteOut" : "c_WriteOut") << ".");
      entry.dontWriteOut = dontwriteout;
    }
 
    B2DEBUG(100, "An " << accessor.readableName() << " was registered once more.");
    return true;
  }
 
  // check reserved names
  if (array and name == "ALL") {
    B2ERROR("Creating an array with the reserved name 'ALL' is not allowed!");
    return false;
  }
 
  // Add the DataStore entry
  m_storeEntryMap[durability][name] = StoreEntry(array, objClass, name, dontwriteout);
 
  B2DEBUG(100, "Successfully registered " << accessor.readableName());
  return true;
}

registerRelation()

bool registerRelation	(	const StoreAccessorBase &	fromArray,
		const StoreAccessorBase &	toArray,
		EDurability	durability,
		EStoreFlags	storeFlags,
		const std::string &	namedRelation )

Register a relation in the DataStore map.

This must be called in the initialization phase. Otherwise an error is returned.

Parameters

fromArray	Origin of the relation
toArray	Target of the relation
durability	Decide with which durability map you want to perform the requested action.
storeFlags	ORed combination of DataStore::EStoreFlags.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

True if the registration succeeded.

See also

DependencyMap

Definition at line 241 of file DataStore.cc.

{
  if (!fromArray.isArray())
    B2FATAL(fromArray.readableName() << " is not an array!");
  if (!toArray.isArray())
    B2FATAL(toArray.readableName() << " is not an array!");
 
  // check the the namedRelation only contains regular characters
  if (!std::regex_match(namedRelation, m_regexNamedRelationCheck))
    B2FATAL("Named Relations can only contain alphabetic characters, given was: " << namedRelation);
 
  const std::string& relName = relationName(fromArray.getName(), toArray.getName(), namedRelation);
  /*
  if ((fromArray.notWrittenOut() or toArray.notWrittenOut()) and !(storeFlags & c_DontWriteOut)) {
    B2WARNING("You're trying to register a persistent relation " << relName << " from/to an array which is not written out (DataStore::c_DontWriteOut flag)! Relation will also not be saved!");
    storeFlags |= c_DontWriteOut;
  }
  */
 
  if (fromArray.getDurability() > durability or toArray.getDurability() > durability) {
    B2FATAL("Tried to create a relation '" << relName << "' with a durability larger than the StoreArrays it relates");
  }
 
  return DataStore::Instance().registerEntry(relName, durability, RelationContainer::Class(), false, storeFlags);
}

relationName()

static std::string relationName ( const std::string & fromName, const std::string & toName, std::string const & namedRelation = "" )

inlinestatic

Return storage name for a relation between two arrays of the given names.

Definition at line 180 of file DataStore.h.

    {
      std::string s;
      s.reserve(fromName.length() + toName.length() + 2);
      s += fromName;
      s += "To";
      s += toName;
      if (namedRelation.length() > 0) {
        s += "Named";
        // Characters are not escaped here, because in registerRelation, the namedRelation
        // given is checked to contain no special characters or white spaces
        s += namedRelation;
      }
      return s;
    }

replaceData()

void replaceData	(	const StoreAccessorBase &	from,
		const StoreAccessorBase &	to )

For two StoreAccessors of same type, move all data in 'from' into 'to', discarding previous contents of 'to' and leaving 'from' empty.

Meta-data like c_DontWriteOut flags or info about associated arrays for RelationContainers is not replaced.

Definition at line 341 of file DataStore.cc.

{
  StoreEntry* fromEntry = getEntry(from);
  StoreEntry* toEntry = getEntry(to);
  if (!fromEntry)
    B2FATAL("No " << from.readableName() << " exists in the DataStore!");
  if (!toEntry)
    B2FATAL("No " << to.readableName() << " exists in the DataStore!");
  if (from.isArray() != to.isArray() or from.getClass() != to.getClass())
    B2FATAL("cannot replace " << to.readableName() << " with " << from.readableName() << " (incompatible types)!");
 
  if (!fromEntry->ptr) {
    //since we don't need to move any data, just invalidate toEntry instead.
    toEntry->ptr = nullptr;
  } else if (fromEntry->isArray) {
    if (!toEntry->ptr)
      toEntry->ptr = toEntry->object;
    toEntry->getPtrAsArray()->Delete();
 
    fixAbsorbObjects(fromEntry->getPtrAsArray(), toEntry->getPtrAsArray());
    updateRelationsObjectCache(*toEntry);
  } else if (fromEntry->objClass == RelationContainer::Class()) {
    if (!toEntry->ptr)
      toEntry->ptr = toEntry->object;
    auto* fromRel = static_cast<RelationContainer*>(fromEntry->ptr);
    auto* toRel = static_cast<RelationContainer*>(toEntry->ptr);
 
    toRel->elements().Delete();
 
    fixAbsorbObjects(&fromRel->elements(), &toRel->elements());
 
    //indices need a rebuild
    fromRel->setModified(true);
    toRel->setModified(true);
  } else {
    delete toEntry->object;
 
    toEntry->object = fromEntry->ptr->Clone();
    toEntry->ptr = toEntry->object;
 
    fromEntry->ptr = nullptr;
  }
}

requireInput()

bool requireInput

(

const StoreAccessorBase &

accessor

)

Produce ERROR message if no entry of the given type is registered in the DataStore.

Note

can only be used in initialize() function

Parameters

accessor

Encapsulates name, durability, and type

Returns

True if the requested object exists.

See also

DependencyMap

Definition at line 720 of file DataStore.cc.

{
  if (m_initializeActive) {
    m_dependencyMap->getCurrentModuleInfo().addEntry(accessor.getName(), DependencyMap::c_Input,
                                                     (accessor.getClass() == RelationContainer::Class()));
  } else {
    B2FATAL("Attempt to require input " << accessor.readableName() <<
            " outside of the initialization phase. Please move isRequired() calls into your Module's initialize() function.");
  }
 
  if (!getEntry(accessor)) {
    B2ERROR("The required " << accessor.readableName() << " does not exist. Maybe you forgot the module that registers it?");
    return false;
  }
  return true;
}

requireRelation()

bool requireRelation	(	const StoreAccessorBase &	fromArray,
		const StoreAccessorBase &	toArray,
		EDurability	durability,
		std::string const &	namedRelation )

Produce ERROR message if no relation of given durability exists between fromArray and toArray (in that direction).

Note

can only be used in initialize() function

Parameters

fromArray	Origin of the relation
toArray	Target of the relation
durability	Decide with which durability map you want to perform the requested action.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

True if the requested object exists.

See also

DependencyMap

Definition at line 747 of file DataStore.cc.

{
  if (!m_initializeActive) {
    B2FATAL("Attempt to require relation " << fromArray.readableName() << " -> " << toArray.readableName() <<
            " outside of the initialization phase. Please move requireRelationTo() calls into your Module's initialize() function.");
  }
 
  if (!fromArray.isArray())
    B2FATAL(fromArray.readableName() << " is not an array!");
  if (!toArray.isArray())
    B2FATAL(toArray.readableName() << " is not an array!");
 
  const std::string& relName = relationName(fromArray.getName(), toArray.getName(), namedRelation);
  return DataStore::Instance().requireInput(StoreAccessorBase(relName, durability, RelationContainer::Class(), false));
}

reset() [1/2]

void reset

(

)

Clears contents of the datastore (all durabilities)

Called by the framework. Users should usually not use this function without good reason.

Definition at line 73 of file DataStore.cc.

{
  B2DEBUG(31, "DataStore::reset(): Removing all elements from DataStore");
  m_initializeActive = true;
  m_dependencyMap->clear();
 
  for (int i = 0; i < c_NDurabilityTypes; i++)
    reset((EDurability)i);
 
  m_storeEntryMap.clear();
}

reset() [2/2]

void reset

(

EDurability

durability

)

Frees memory occupied by data store items and removes all objects from the map.

Afterwards, m_storeEntryMap[durability] is empty. Called by the framework. Users should usually not use this function without good reason.

Definition at line 85 of file DataStore.cc.

{
  m_storeEntryMap.reset(durability);
 
  //invalidate any cached relations (expect RelationArrays to remain valid)
  RelationIndexManager::Instance().reset();
}

setInitializeActive()

void setInitializeActive

(

bool

active

)

Setter for m_initializeActive.

This should only be called by EventProcessor.

Definition at line 93 of file DataStore.cc.

{
  m_initializeActive = active;
 
  static bool firstCall = true;
  if (firstCall) {
    atexit(cleanDataStore);
    firstCall = false;
  }
}

switchID()

void switchID

(

const std::string &

id

)

switch to DataStore with given ID.

Definition at line 792 of file DataStore.cc.

{
  if (id == m_storeEntryMap.currentID())
    return;
 
  //remember to clear caches
  RelationIndexManager::Instance().reset();
 
  m_storeEntryMap.switchID(id);
}

updateRelationsObjectCache()

void updateRelationsObjectCache ( StoreEntry & entry )

staticprivate

For an array containing RelationsObjects, update index and entry cache for entire contents.

You must ensure the array actually contains objects inheriting from RelationsObject!

Definition at line 385 of file DataStore.cc.

{
  const TClonesArray* array = static_cast<TClonesArray*>(entry.ptr);
  const int nEntries = array->GetEntriesFast();
  for (int i = 0; i < nEntries; i++) {
    auto* relobj = static_cast<RelationsObject*>(array->At(i));
    relobj->m_cacheArrayIndex = i;
    relobj->m_cacheDataStoreEntry = &entry;
  }
}

Member Data Documentation

c_NDurabilityTypes

const int c_NDurabilityTypes = 2

static

Number of Durability Types.

Definition at line 63 of file DataStore.h.

m_dependencyMap

DependencyMap* m_dependencyMap

private

Collect information about the dependencies between modules.

Definition at line 637 of file DataStore.h.

m_initializeActive

bool m_initializeActive

private

True if modules are currently being initialized.

Creating new map slots is only allowed in a Module's initialize() function.

Definition at line 628 of file DataStore.h.

m_regexNamedRelationCheck

const std::regex m_regexNamedRelationCheck = std::regex("^[a-zA-Z]*$")

private

Regular expression to check that no special characters and no white spaces are in the string given for namedRelations.

Definition at line 634 of file DataStore.h.

m_storeEntryMap

SwitchableDataStoreContents m_storeEntryMap

private

Maps (name, durability) key to StoreEntry objects.

Definition at line 621 of file DataStore.h.

s_DoCleanup

bool s_DoCleanup = false

static

Global flag to to decide if we can do normal cleanup.

If the normal basf2 execution is bypassed, e.g. in tests or separate binaries, we cannot guarantee that exit handlers are called in the correct order. Since this may lead to double deletion of objects through ROOT and misleading error stack traces, we will skip cleanup in these exceptional cases.

Definition at line 100 of file DataStore.h.

---

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

• framework/datastore/include/DataStore.h
• framework/datastore/src/DataStore.cc