DataStore.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2011 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Heck, Thomas Kuhr, Martin Ritter,                 *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#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 
    };
    const static int c_NDurabilityTypes = 2;
 
    enum EStoreFlags {
      c_WriteOut = 0,                
      c_DontWriteOut = 1,            
      c_ErrorIfAlreadyRegistered = 2,
    };
 
    enum ESearchSide {
      c_FromSide, 
      c_ToSide,   
      c_BothSides 
    };
 
 
    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;
    }
 
    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);
    }
 
    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 TClass* t);
 
    template<class T> static std::string defaultArrayName()
    {
      const static std::string s = defaultArrayName(defaultObjectName<T>());
      return s;
    }
 
    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 FROM, class TO> static std::string defaultRelationName()
    {
      const static std::string s = relationName(defaultArrayName<FROM>(), defaultArrayName<TO>());
      return s;
    }
 
    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;
    }
 
    //------------------------------ 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);
    }
 
    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 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);
    }
 
#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;
 
 
    //------------------------------ 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);
    std::string currentID() const;
    void switchID(const std::string& id);
    void copyEntriesTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
    void copyContentsTo(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]);
      }
 
      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 = {});
      void copyContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});
      void createNewDataStoreID(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; 
    };
    SwitchableDataStoreContents m_storeEntryMap;
 
 
    bool m_initializeActive;
 
    const std::regex m_regexNamedRelationCheck = std::regex("^[a-zA-Z]*$");
 
    DependencyMap* m_dependencyMap;
  };
 
  ADD_BITMASK_OPERATORS(DataStore::EStoreFlags); 
} // namespace Belle2