DataStore.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <framework/datastore/StoreEntry.h>
#include <framework/core/BitMask.h>
 
#if defined(__CINT__) || defined(__ROOTCLING__) || defined(R__DICTIONARY_FILENAME)
//a few methods use these, but are only included in dictionaries
#include <framework/datastore/RelationVector.h>
#include <framework/datastore/RelationEntry.h>
#endif
 
#include <regex>
#include <array>
#include <vector>
#include <string>
#include <map>
 
class TObject;
class TClass;
 
namespace Belle2 {
  class StoreAccessorBase;
  class DependencyMap;
  class RelationVectorBase;
  template <class T> class RelationVector;
  struct RelationEntry;

  class DataStore {
  public:
    //----------------------------------- enums and typedefs ---------------------------------------------------
    enum EDurability {
      c_Event,     
      c_Persistent 
    };
    enum EDurability {…};

    const static int c_NDurabilityTypes = 2;

    enum EStoreFlags {
      c_WriteOut = 0,                
      c_DontWriteOut = 1,            
      c_ErrorIfAlreadyRegistered = 2,
    };
    enum EStoreFlags {…};

    enum ESearchSide {
      c_FromSide, 
      c_ToSide,   
      c_BothSides 
    };
    enum ESearchSide {…};
 

    typedef Belle2::StoreEntry StoreEntry;
 
    // Convenient typedefs.
    typedef std::map<std::string, StoreEntry> StoreEntryMap;  
    typedef StoreEntryMap::iterator StoreEntryIter;              
    typedef StoreEntryMap::const_iterator StoreEntryConstIter;   
    typedef std::array<StoreEntryMap, c_NDurabilityTypes> DataStoreContents; 
 

    static bool s_DoCleanup;
 
 
    //--------------------------------- Instance ---------------------------------------------------------------
    static DataStore& Instance();
 
    //--------------------------------- default name stuff -----------------------------------------------------

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

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

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

    static std::string defaultObjectName(const TClass* t);

    template<class T> static std::string defaultObjectName()
    {
      const static std::string s = defaultObjectName(T::Class_Name());
      return s;
    }
    template<class T> static std::string defaultObjectName() {…}

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

    template<class T> static std::string objectName(const std::string& name)
    {
      return ((name.empty()) ? defaultObjectName<T>() : name);
    }
    template<class T> static std::string objectName(const std::string& name) {…}

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

    static std::string defaultArrayName(const TClass* t);

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

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

    template<class T> static std::string arrayName(const std::string& name)
    {
      return ((name.empty()) ? defaultArrayName<T>() : name);
    }
    template<class T> static std::string arrayName(const std::string& name) {…}

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

    static std::string relationName(const std::string& fromName, const std::string& toName,
                                    std::string const& namedRelation = "")
    {
      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;
    }
    static std::string relationName(const std::string& fromName, const std::string& toName, {…}
 
    //------------------------------ Accessing objects and arrays ----------------------------------------------
    bool registerEntry(const std::string& name, EDurability durability,
                       TClass* objClass, bool array, EStoreFlags storeFlags);

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

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

    bool requireInput(const StoreAccessorBase& accessor);

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

    bool optionalInput(const StoreAccessorBase& accessor);

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

    StoreEntry* getEntry(const StoreAccessorBase& accessor);

    TObject** getObject(const StoreAccessorBase& accessor);

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

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

    StoreEntryMap& getStoreEntryMap(EDurability durability) { return m_storeEntryMap[durability]; }
 

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

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

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

    static void addRelationFromTo(const TObject* fromObject, const TObject* toObject, float weight = 1.0,
                                  const std::string& namedRelation = "")
    {
      DataStore::StoreEntry* fromEntry = nullptr;
      int fromIndex = -1;
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      Instance().addRelation(fromObject, fromEntry, fromIndex, toObject, toEntry, toIndex, weight, namedRelation);
    }
    static void addRelationFromTo(const TObject* fromObject, const TObject* toObject, float weight = 1.0, {…}

    template <class T> static RelationVector<T> getRelationsWithObj(const TObject* object, const std::string& name = "",
        const std::string& namedRelation = "")
    {
      StoreEntry* storeEntry = nullptr;
      int index = -1;
      return RelationVector<T>(Instance().getRelationsWith(c_BothSides, object, storeEntry, index, T::Class(), name, namedRelation));
    }
    template <class T> static RelationVector<T> getRelationsWithObj(const TObject* object, const std::string& name = "", {…}

    template <class T> static T* getRelated(const TObject* object, const std::string& name = "", const std::string& namedRelation = "")
    {
      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);
    }
    template <class T> static T* getRelated(const TObject* object, const std::string& name = "", const std::string& namedRelation = "") {…}
 
#if defined(__CINT__) || defined(__ROOTCLING__) || defined(R__DICTIONARY_FILENAME)

    static RelationVector<TObject> getRelationsWithObj(const TObject* object, const std::string& name)
    {
      return getRelationsWithObj<TObject>(object, name);
    }
    static TObject* getRelated(const TObject* object, const std::string& name) { return getRelated<TObject>(object, name); }
#endif

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

    std::vector<std::string> getListOfRelatedArrays(const StoreAccessorBase& array) const;

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

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

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

    std::vector<std::string> getSortedListOfDataStore(EDurability durability) const;
 
 
    //------------------------------ For internal use --------------------------------------------------
    void setInitializeActive(bool active);

    bool getInitializeActive() const { return m_initializeActive; }

    void invalidateData(EDurability durability);

    void reset(EDurability durability);

    void reset();

    DependencyMap& getDependencyMap() { return *m_dependencyMap; }
 

    void createNewDataStoreID(const std::string& id);
    void createEmptyDataStoreID(const std::string& id);
    std::string currentID() const;
    void switchID(const std::string& id);
    void copyEntriesTo(const std::string& id, const std::vector<std::string>& entrylist_event = {}, bool mergeEntries = false);
    void copyContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
    void mergeContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
 
  private:
    explicit DataStore();
    DataStore(const DataStore&) = delete;
    DataStore& operator=(const DataStore&) = delete;
    ~DataStore();

    bool checkType(const StoreEntry& entry, const StoreAccessorBase& accessor) const;

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

    static void updateRelationsObjectCache(StoreEntry& entry);

    class SwitchableDataStoreContents {
    public:
      SwitchableDataStoreContents();
      void clear();
      void reset(EDurability durability);
      void invalidateData(EDurability durability);
      const StoreEntryMap& operator [](int durability) const { return m_entries[m_currentIdx][durability]; }
      StoreEntryMap& operator [](int durability)
      {
        //reuse const implementation
        const SwitchableDataStoreContents* this2 = this;
        return const_cast<StoreEntryMap&>((*this2)[durability]);
      }
      StoreEntryMap& operator [](int durability) {…}

      void switchID(const std::string& id);
      const std::string& currentID() const { return m_currentID; }
      void copyEntriesTo(const std::string& id, const std::vector<std::string>& entrylist_event = {}, bool mergeEntries = false);
      void copyContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
      void mergeContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
      void createNewDataStoreID(const std::string& id);
      void createEmptyDataStoreID(const std::string& id);
    private:
      std::vector<DataStoreContents> m_entries; 
      std::map<std::string, int> m_idToIndexMap; 
      std::string m_currentID = ""; 
      int m_currentIdx = 0; 
    };
    class SwitchableDataStoreContents {…};

    SwitchableDataStoreContents m_storeEntryMap;
 

    bool m_initializeActive;

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

    DependencyMap* m_dependencyMap;
  };
  class DataStore {…};
 
  ADD_BITMASK_OPERATORS(DataStore::EStoreFlags); 
} // namespace Belle2