RelationIndexManager.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/RelationIndexContainer.h>
 
#include <array>
#include <memory>
#include <map>
 
namespace Belle2 {
  class RelationIndexManager {
  public:
    static RelationIndexManager& Instance();
 
    template<class FROM, class TO> std::shared_ptr<RelationIndexContainer<FROM, TO>> get(const RelationArray& relation)
    {
      const static bool doTypeCheck = (FROM::Class() != TObject::Class() or TO::Class() != TObject::Class());
      if (doTypeCheck)
        relation.isValid();
 
      const std::string& name = relation.getName();
      DataStore::EDurability durability = relation.getDurability();
      RelationMap& relations =  m_cache[durability];
      std::shared_ptr<RelationIndexContainer<FROM, TO>> indexContainer;
      RelationMap::iterator it = relations.find(name);
      if (it != relations.end()) {
        //if existing array is of wrong type, we'll overwrite the shared_ptr here, but the index will live on with any RelationIndex objects that use it.
        indexContainer = std::dynamic_pointer_cast<RelationIndexContainer<FROM, TO>>(it->second);
      }
      if (!indexContainer) {
        indexContainer.reset(new RelationIndexContainer<FROM, TO>(relation));
        relations[name] = indexContainer;
      } else {
        indexContainer->rebuild(false);
      }
      return indexContainer;
    }
 
    void clear(DataStore::EDurability durability = DataStore::c_Event);
 
    void reset()
    {
      for (int i = 0; i < DataStore::c_NDurabilityTypes; i++)
        m_cache[i].clear();
    }
 
  protected:
    RelationIndexManager() = default;
    RelationIndexManager(const RelationIndexManager&) = delete;
    RelationIndexManager(RelationIndexManager&&) = delete;
    RelationIndexManager& operator=(const RelationIndexManager&) = delete;
 
    template<class FROM, class TO> std::shared_ptr<RelationIndexContainer<FROM, TO>> getIndexIfExists(const std::string& name,
        DataStore::EDurability durability) const
    {
      const RelationMap& relations =  m_cache[durability];
      RelationMap::const_iterator it = relations.find(name);
      if (it != relations.end()) {
        return std::dynamic_pointer_cast<RelationIndexContainer<FROM, TO>>(it->second);
      } else {
        return nullptr;
      }
    }
 
    ~RelationIndexManager()
    {
      reset();
    }
 
    typedef std::map<std::string, std::shared_ptr<RelationIndexBase>> RelationMap;
    typedef std::array<RelationMap, DataStore::c_NDurabilityTypes> RelationCache;
    RelationCache m_cache;
 
    friend class DataStore;
  };
 
} // end namespace Belle2