RelationIndex.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/RelationIndexManager.h>
 
#include <boost/range/iterator_range.hpp>
 
namespace Belle2 {
  template <class T> class StoreArray;
 
  template<class FROM, class TO> class RelationIndex {
  public:
    typedef typename RelationIndexContainer<FROM, TO>::Element Element;
 
    typedef typename RelationIndexContainer<FROM, TO>::ElementIndex ElementIndex;
 
    typedef typename ElementIndex::template nth_index<0>::type index_from;
 
    typedef typename ElementIndex::template nth_index<1>::type index_to;
 
    typedef typename index_from::const_iterator iterator_from;
 
    typedef typename index_to::const_iterator iterator_to;
 
    typedef boost::iterator_range<iterator_from> range_from;
 
    typedef boost::iterator_range<iterator_to> range_to;
 
    explicit RelationIndex(const std::string& name = (DataStore::defaultRelationName<FROM, TO>()),
                           DataStore::EDurability durability = DataStore::c_Event):
      m_index(RelationIndexManager::Instance().get<FROM, TO>(RelationArray(name, durability))),
      m_from(m_index->index().template get<0>()),
      m_to(m_index->index().template get<1>()) {}
 
    RelationIndex(const StoreArray<FROM>& from, const StoreArray<TO>& to, const std::string& name = "",
                  DataStore::EDurability durability = DataStore::c_Event):
      m_index(RelationIndexManager::Instance().get<FROM, TO>(RelationArray(from, to, name, durability))),
      m_from(m_index->index().template get<0>()),
      m_to(m_index->index().template get<1>()) {}
 
    operator bool() const { return *(m_index.get()); }
 
    range_from getElementsFrom(const FROM* from) const { return m_from.equal_range(from); }
 
    range_from getElementsFrom(const FROM& from) const { return m_from.equal_range(&from); }
 
    range_to getElementsTo(const TO* to) const { return m_to.equal_range(to); }
 
    range_to getElementsTo(const TO& to) const { return m_to.equal_range(&to); }
 
    const Element* getFirstElementFrom(const FROM& from) const { return getFirstElementFrom(&from); }
 
    const Element* getFirstElementFrom(const FROM* from) const
    {
      iterator_from it = m_from.find(from);
      if (it == m_from.end()) return 0;
      return &(*it);
    }
 
    const Element* getFirstElementTo(const TO& to) const { return getFirstElementTo(&to); }
 
    const Element* getFirstElementTo(const TO* to) const
    {
      iterator_to it = m_to.find(to);
      if (it == m_to.end()) return 0;
      return &(*it);
    }
 
    AccessorParams getAccessorParams()     const { return m_index->getAccessorParams(); }
 
    const AccessorParams& getFromAccessorParams() const { return m_index->getFromAccessorParams(); }
 
    const AccessorParams& getToAccessorParams()   const { return m_index->getToAccessorParams(); }
 
    size_t size() const { return m_index->index().size(); }
  protected:
    const std::shared_ptr<RelationIndexContainer<FROM, TO>> m_index;
 
    const index_from& m_from;
 
    const index_to& m_to;
  };
 
} // end namespace Belle2