DataStore::SwitchableDataStoreContents Class Reference

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

Public Member Functions
void	clear ()
	same as calling reset() for all durabilities + all non-default datastore IDs are removed.
void	reset (EDurability durability)
	Frees memory occupied by data store items and removes all objects from the map.
void	invalidateData (EDurability durability)
	Clears all registered StoreEntry objects of a specified durability, invalidating all objects.
const StoreEntryMap &	operator[] (int durability) const
	Get StoreEntry map for given durability (and current DataStore ID).
StoreEntryMap &	operator[] (int durability)
	Get StoreEntry map for given durability (and current DataStore ID).
void	switchID (const std::string &id)
	switch to DataStore with given ID.
const std::string &	currentID () const
	returns ID of current DataStore.
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.
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.

Private Attributes
std::vector< DataStoreContents >	m_entries
	wrapped DataStoreContents.
std::map< std::string, int >	m_idToIndexMap
	Maps DataStore ID to index in m_entries.
std::string	m_currentID = ""
	currently active DataStore ID.
int	m_currentIdx = 0
	index of currently active DataStore.

Detailed Description

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

Accessed only through operator[].

Definition at line 581 of file DataStore.h.

Constructor & Destructor Documentation

SwitchableDataStoreContents()

SwitchableDataStoreContents

(

)

Definition at line 821 of file DataStore.cc.

                                                                 :
  m_entries(1)
{
  m_idToIndexMap[""] = 0;
}

Member Function Documentation

clear()

void clear

(

)

same as calling reset() for all durabilities + all non-default datastore IDs are removed.

Definition at line 1154 of file DataStore.cc.

{
  for (int i = 0; i < c_NDurabilityTypes; i++)
    reset((EDurability)i);
 
  m_entries.clear();
  m_entries.resize(1);
  m_idToIndexMap.clear();
  m_idToIndexMap[""] = 0;
  m_currentID = "";
  m_currentIdx = 0;
}

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 946 of file DataStore.cc.

{
  int targetidx = m_idToIndexMap.at(id);
  auto& targetMaps = m_entries[targetidx];
  const auto& sourceMaps = m_entries[m_currentIdx];
 
  for (int iDurability = 0; iDurability < c_NDurabilityTypes; iDurability++) {
    for (const auto& entrypair : sourceMaps[iDurability]) {
      const StoreEntry& fromEntry = entrypair.second;
      //does this exist in target?
      if (targetMaps[iDurability].count(fromEntry.name) == 0) {
        continue;
      }
 
      if (!entrylist_event.empty()) {
        //skip all entries of other durabilities
        if (iDurability != c_Event)
          continue;
        //skip all entries not found in entrylist_event
        if (std::find(entrylist_event.begin(), entrylist_event.end(), fromEntry.name) == entrylist_event.end())
          continue;
      }
 
      StoreEntry& target = targetMaps[iDurability][fromEntry.name];
 
      //copy contents into target object
      if (not fromEntry.ptr) {
        if (!target.object)
          target.recoverFromNullObject();
        target.ptr = nullptr;
      } else {
        //TODO there is some optimisation opportunity here, e.g. by only cloning the entries of a TClonesArray instead of the array itself
        delete target.object;
        target.object = fromEntry.object->Clone();
        target.ptr = target.object;
      }
    }
  }
 
}

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 850 of file DataStore.cc.

{
  std::vector<std::string> entrylist;
  if (entrylist_event.size() == 1 and entrylist_event.at(0) == "ALL") {
    entrylist = DataStore::Instance().getSortedListOfDataStore(c_Event);
  } else {
    entrylist = entrylist_event;
  }
 
  if (mergeEntries) {
    // Make sure that EventMetaData is always merged
    if (std::find(entrylist.begin(), entrylist.end(), "EventMetaData") == entrylist.end()) {
      entrylist.push_back("EventMetaData");
      B2INFO("It is required to merge the 'EventMetaData' for consistency. Added.");
    }
  }
 
  //collect the entries for which we do not have to fix duplicate pointers
  std::vector<std::string> skipEntries;
 
  int targetidx;
  if (m_idToIndexMap.count(id) == 0) {
    //new DataStore & full copy
    if (!entrylist.empty())
      B2FATAL("entrlylist_event given for new DS id. This shouldn't happen, report to framework author.");
    targetidx = m_entries.size();
    m_idToIndexMap[id] = targetidx;
 
    //copy entries
    m_entries.push_back(m_entries[m_currentIdx]);
  } else if (!entrylist.empty()) {
    targetidx = m_idToIndexMap.at(id);
    // if we are merging DataStores, we need to register a new object that stores at which indices the arrays have been merged
    if (mergeEntries) {
      if (m_entries[targetidx][c_Event].count("MergedArrayIndices") != 0) {
        B2FATAL("MergedArrayIndices already exists. This should not happen.");
      }
      m_entries[targetidx][c_Event]["MergedArrayIndices"] = StoreEntry(false, EventExtraInfo::Class(), "MergedArrayIndices", false);
    }
    for (std::string& entryname : entrylist) {
      //copy only given entries (in c_Event)
      if (m_entries[m_currentIdx][c_Event].count(entryname) == 0) {
        continue;
      }
      if (m_entries[targetidx][c_Event].count(entryname) != 0) {
        if (mergeEntries) {
          // Skip Store-Arrays and Relations..
          if (m_entries[targetidx][c_Event][entryname].isArray
              or m_entries[targetidx][c_Event][entryname].objClass == RelationContainer::Class()) { //do nothing
            // ..but not Store-Objects
          } else {
            // We have to create a new StoreEntry as the name of the key in the map changes
            if (m_entries[targetidx][c_Event].count(entryname + "_indepPath") != 0) {
              B2FATAL(entryname + "_indepPath already exists. This should not happen.");
            }
            m_entries[targetidx][c_Event][entryname + "_indepPath"] = StoreEntry(false, m_entries[targetidx][c_Event][entryname].objClass,
                                                                      entryname + "_indepPath", m_entries[targetidx][c_Event][entryname].dontWriteOut);
          }
          skipEntries.push_back(entryname);
          continue;
        } else {
          B2WARNING("Independent path: entry '" << entryname << "' already exists in DataStore '" << id <<
                    "'! This will likely break something.");
        }
      } else {
        m_entries[targetidx][c_Event][entryname] = m_entries[m_currentIdx][c_Event][entryname];
      }
    }
  } else {
    B2FATAL("no entrlylist_event given, not new DS id. This shouldn't happen, report to framework author.");
  }
 
  //fix duplicate pointers
  for (int iDurability = 0; iDurability < c_NDurabilityTypes; iDurability++) {
    for (auto& entrypair : m_entries[targetidx][iDurability]) {
      if (not entrypair.second.object)
        B2FATAL("createNewDataStoreID(): object '" << entrypair.first << " already null (this should never happen).");
      if (!entrylist.empty()) {
        //skip all entries of other durabilities
        if (iDurability != c_Event)
          continue;
        //skip all entries not found in entrylist
        if (std::find(entrylist.begin(), entrylist.end(), entrypair.first) == entrylist.end())
          continue;
        //don't fix the ownership for these
        if (std::find(skipEntries.begin(), skipEntries.end(), entrypair.first) != skipEntries.end())
          continue;
      }
 
      entrypair.second.object = nullptr; //remove duplicate ownership
      entrypair.second.ptr = nullptr;
    }
  }
}

createEmptyDataStoreID()

void createEmptyDataStoreID

(

const std::string &

id

)

creates empty datastore with given id.

Definition at line 838 of file DataStore.cc.

{
  //does this id already exist?
  if (m_idToIndexMap.count(id) > 0)
    return;
 
  int targetidx = m_entries.size();
  m_idToIndexMap[id] = targetidx;
 
  m_entries.push_back(DataStoreContents());
}

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 827 of file DataStore.cc.

{
  //does this id already exist?
  if (m_idToIndexMap.count(id) > 0)
    return;
 
  copyEntriesTo(id);
  //copy actual contents, fixing pointers
  copyContentsTo(id);
}

currentID()

const std::string & currentID ( ) const

inline

returns ID of current DataStore.

Definition at line 603 of file DataStore.h.

{ return m_currentID; }

invalidateData()

void invalidateData

(

EDurability

durability

)

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

Definition at line 1177 of file DataStore.cc.

{
  for (auto& map : m_entries)
    for (auto& mapEntry : map[durability])
      mapEntry.second.invalidate();
}

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 987 of file DataStore.cc.

{
  if (entrylist_event.empty()) {
    B2WARNING("Nothing to merge. Returning.");
    return;
  }
 
  std::vector<std::string> entrylist;
  if (entrylist_event.size() == 1 and entrylist_event.at(0) == "ALL") {
    entrylist = DataStore::Instance().getSortedListOfDataStore(c_Event);
  } else {
    entrylist = entrylist_event;
  }
 
  int targetidx = m_idToIndexMap.at(id);
  auto& targetMaps = m_entries[targetidx];
  const auto& sourceMaps = m_entries[m_currentIdx];
 
  // we need to know the length of the original StoreArrays in order to fix the Relations
  if (targetMaps[c_Event].count("MergedArrayIndices") == 0) {
    B2FATAL("Did not find MergedArrayIndices in target. This should not happen.");
  }
  StoreEntry& target_arrayIndices = targetMaps[c_Event]["MergedArrayIndices"];
  target_arrayIndices.recreate();
  EventExtraInfo* arrayIndices = static_cast<EventExtraInfo*>(target_arrayIndices.ptr);
 
  // we have to go through the list in this order to make sure StoreArrays are merged before their Relations
  for (std::string nextEntry : entrylist) {
    for (const auto& entrypair : sourceMaps[c_Event]) {
      const StoreEntry& fromEntry = entrypair.second;
      if (fromEntry.name != nextEntry) {
        continue;
      }
 
      //does this exist in target?
      if (targetMaps[c_Event].count(fromEntry.name) == 0) {
        continue;
      }
 
      StoreEntry& target = targetMaps[c_Event][fromEntry.name];
 
      //copy contents into target object
      if (!fromEntry.ptr) {
        if (!target.object) {
          target.recoverFromNullObject();
          target.ptr = nullptr;
        } else {
          // keep the content as it is before merging and indicate this by the index
          if (target.isArray) {
            arrayIndices->addExtraInfo(target.name, target.getPtrAsArray()->GetEntriesFast());
          }
        }
      } else {
        // array-type object
        if (target.isArray) {
          if (!target.ptr) {
            target.object = fromEntry.object->Clone();
            target.ptr = target.object;
 
            arrayIndices->addExtraInfo(target.name, 0);
          } else {
            if (target.objClass != fromEntry.objClass) {
              B2FATAL("Cannot merge StoreArrays " << target.name << "as they are of different classes.");
            }
 
            arrayIndices->addExtraInfo(target.name, target.getPtrAsArray()->GetEntriesFast());
 
            if (fromEntry.getPtrAsArray()->GetEntriesFast() == 0) {
              continue;
            }
 
            // TClonesArray has no easy way to add objects to it
            // Instead work around this by cloning and absorbing the TClonesArray `fromEntry`
            // Also use `fixAbsorbObjects` define in this file to work around some potential memory leak
            // TODO: check if clone makes sense? or should we rather move the whole obj to avoid memleaks?
            TClonesArray* fromArr = static_cast<TClonesArray*>(fromEntry.getPtrAsArray()->Clone());
            fixAbsorbObjects(fromArr, target.getPtrAsArray());
 
            // update the cache
            updateRelationsObjectCache(target);
            delete fromArr;
          }
        } else {
          if (!target.ptr) {
            target.object = fromEntry.object->Clone();
            target.ptr = target.object;
          } else {
            // relation-type object
            if (fromEntry.objClass == RelationContainer::Class()) {
              auto* fromRelContainer = static_cast<RelationContainer*>(fromEntry.ptr);
              if (fromRelContainer->isDefaultConstructed()) {
                continue;
              }
 
              if (fromRelContainer->getEntries() == 0) {
                continue;
              }
 
              const std::string& fromName = fromRelContainer->getFromName();
              const std::string& toName = fromRelContainer->getToName();
 
              auto* targetRelContainer = static_cast<RelationContainer*>(target.ptr);
              if (not arrayIndices->hasExtraInfo(fromName)  || not arrayIndices->hasExtraInfo(toName)) {
                B2WARNING("Skipping merging of relation " << fromEntry.name
                          << ". The StoreArrays " << fromName << " and " << toName << " have to be merged before.");
                // clear relation just to make sure nobody actually uses it
                targetRelContainer->Clear();
                continue;
              }
 
              // Make sure everything is properly initialized
              if (targetRelContainer->isDefaultConstructed()) {
                targetRelContainer->setFromName(fromName);
                targetRelContainer->setFromDurability(c_Event);
                targetRelContainer->setToName(toName);
                targetRelContainer->setToDurability(c_Event);
              }
 
              // add relation
              TClonesArray& relations = targetRelContainer->elements();
              // The fast way would be to add the relation also to the RelationIndexManager (this is a cache for relations)
              // However, it seems to have some issues with the switching of the DataStore
              // (it simply uses the name of the relation for the mapping, but it exists twice..)
              // Instead, force rebuilding of the cache later
 
              for (int i = 0; i < fromRelContainer->getEntries(); i++) {
                const RelationElement& rel = fromRelContainer->getElement(i);
                unsigned int fromIndex = arrayIndices->hasExtraInfo(fromName) ? rel.getFromIndex() + arrayIndices->getExtraInfo(fromName) : -1;
 
                for (size_t rel_idx = 0; rel_idx < rel.getSize(); rel_idx++) {
                  unsigned int toIndex = arrayIndices->hasExtraInfo(toName) ? rel.getToIndex(rel_idx) + arrayIndices->getExtraInfo(toName) : -1;
                  float weight = rel.getWeight(rel_idx);
                  new (relations.AddrAt(relations.GetLast() + 1)) RelationElement(fromIndex, toIndex, weight);
                }
              }
 
              // as mentioned above, rebuild of cache
              targetRelContainer->setModified(true);
 
              // simple object (cannot be merged, instead keep both)
            } else {
              std::string nameRenamed = fromEntry.name + "_indepPath";
              if (targetMaps[c_Event].count(nameRenamed) == 0) {
                B2FATAL("Did not find " << nameRenamed << " in target. This should not happen.");
              }
              StoreEntry& target_renamed = targetMaps[c_Event][nameRenamed];
              target_renamed.object = fromEntry.object->Clone();
              target_renamed.ptr = target_renamed.object;
            }
          }
        }
      }
    }
  }
 
}

operator[]() [1/2]

StoreEntryMap & operator[] ( int  durability )

inline

Get StoreEntry map for given durability (and current DataStore ID).

Definition at line 593 of file DataStore.h.

      {
        //reuse const implementation
        const SwitchableDataStoreContents* this2 = this;
        return const_cast<StoreEntryMap&>((*this2)[durability]);
      }

operator[]() [2/2]

const StoreEntryMap & operator[] ( int  durability ) const

inline

Get StoreEntry map for given durability (and current DataStore ID).

Definition at line 591 of file DataStore.h.

{ return m_entries[m_currentIdx][durability]; }

reset()

void reset

(

EDurability

durability

)

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

Definition at line 1167 of file DataStore.cc.

{
  for (auto& map : m_entries) {
    for (auto& mapEntry : map[durability]) {
      delete mapEntry.second.object;
    }
    map[durability].clear();
  }
}

switchID()

void switchID

(

const std::string &

id

)

switch to DataStore with given ID.

Definition at line 1144 of file DataStore.cc.

{
  //switch
  m_currentID = id;
  m_currentIdx = m_idToIndexMap.at(id);
 
  if ((unsigned int)m_currentIdx >= m_entries.size())
    B2FATAL("out of bounds in SwitchableDataStoreContents::switchID(): " << m_currentIdx << " >= size " << m_entries.size());
}

Member Data Documentation

m_currentID

std::string m_currentID = ""

private

currently active DataStore ID.

Definition at line 617 of file DataStore.h.

m_currentIdx

int m_currentIdx = 0

private

index of currently active DataStore.

Definition at line 618 of file DataStore.h.

m_entries

std::vector<DataStoreContents> m_entries

private

wrapped DataStoreContents.

Definition at line 615 of file DataStore.h.

m_idToIndexMap

std::map<std::string, int> m_idToIndexMap

private

Maps DataStore ID to index in m_entries.

Definition at line 616 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