RelationIndexContainer.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/StoreArray.h>
#include <framework/datastore/RelationArray.h>
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
 
namespace Belle2 {
  class RelationIndexBase {
  public:
 
    virtual ~RelationIndexBase() {}
 
    virtual void clear() = 0;
  };
 
  template<class FROM, class TO> class RelationIndexContainer: public RelationIndexBase {
  public:
 
    struct Element {
 
      Element(RelationElement::index_type indexFrom_,  RelationElement::index_type indexTo_,
              const FROM* from_, const TO* to_,  RelationElement::weight_type weight_):
        indexFrom(indexFrom_), indexTo(indexTo_), from(from_), to(to_), weight(weight_) {}
 
      RelationElement::index_type indexFrom;
 
      RelationElement::index_type indexTo;
 
      const FROM* from;
 
      const TO* to;
 
      RelationElement::weight_type weight;
    };
 
    typedef boost::multi_index::multi_index_container <
    Element,
    boost::multi_index::indexed_by <
    boost::multi_index::ordered_non_unique <
    boost::multi_index::member<Element, const FROM*, &Element::from>
    >,
    boost::multi_index::ordered_non_unique <
    boost::multi_index::member<Element, const TO*, &Element::to>
    >
    >
    > ElementIndex;
 
    operator bool() const { return m_valid; }
 
    const ElementIndex&  index() const { return m_index; }
    ElementIndex&  index() { return m_index; }
 
    AccessorParams getAccessorParams() const { return m_storeRel.getAccessorParams(); }
 
    const AccessorParams& getFromAccessorParams() const { return m_storeFrom; }
 
    const AccessorParams& getToAccessorParams()   const { return m_storeTo; }
 
  protected:
    explicit RelationIndexContainer(const RelationArray& relArray): m_storeRel(relArray), m_valid(false)
    {
      rebuild(true);
    }
 
    RelationIndexContainer(const RelationIndexContainer&) = delete;
 
    RelationIndexContainer& operator=(const RelationIndexContainer&) = delete;
 
    void rebuild(bool force = false);
 
    virtual void clear() override { m_index.clear(); }
 
    ElementIndex m_index;
 
    RelationArray m_storeRel;
 
    AccessorParams m_storeFrom;
 
    AccessorParams m_storeTo;
 
    bool m_valid;
 
    friend class RelationIndexManager;
  };
 
  template<class FROM, class TO> void RelationIndexContainer<FROM, TO>::rebuild(bool force)
  {
    m_valid = m_storeRel.isValid();
    if (!m_valid) {
      B2DEBUG(100, "Relation " << m_storeRel.getName() << " does not exist, cannot build index");
      m_index.clear();
      m_storeFrom = AccessorParams();
      m_storeTo = AccessorParams();
      return;
    }
 
    //Check if relation has been modified since we created the index
    //If not, keep old contents
    if (!force && !m_storeRel.getModified()) return;
 
    B2DEBUG(100, "Building index for " << m_storeRel.getName());
 
    //Reset modification flag
    m_storeRel.setModified(false);
 
    m_index.clear();
 
    //Get related StoreArrays
    m_storeFrom = m_storeRel.getFromAccessorParams();
    m_storeTo = m_storeRel.getToAccessorParams();
    const StoreArray<FROM> storeFrom(m_storeFrom.first, m_storeFrom.second);
    const StoreArray<TO>   storeTo(m_storeTo.first, m_storeTo.second);
 
    //Get number of entries in relation and stores (also checks template type versus DataStore contents)
    const RelationElement::index_type nFrom = storeFrom.getEntries();
    const RelationElement::index_type nTo = storeTo.getEntries();
    const unsigned int nRel = m_storeRel.getEntries();
 
    //Loop over all RelationElements and add them to index
    for (unsigned int i = 0; i < nRel; ++i) {
      const RelationElement& r = m_storeRel[i];
      RelationElement::index_type idxFrom = r.getFromIndex();
      if (idxFrom >= nFrom)
        B2FATAL("Relation " <<  m_storeRel.getName() << " is inconsistent: from-index (" << idxFrom << ") out of range");
      const FROM* from = storeFrom[idxFrom];
 
      //Loop over index and weight vector at once
      const auto& indices = r.getToIndices();
      const auto& weights = r.getWeights();
      auto itIdx = indices.begin();
      auto itWgt = weights.begin();
      const auto& idxEnd = indices.end();
      for (; itIdx != idxEnd; ++itIdx, ++itWgt) {
        const RelationElement::index_type idxTo = *itIdx;
        if (idxTo >= nTo)
          B2FATAL("Relation " <<  m_storeRel.getName() << " is inconsistent: to-index (" << idxTo << ") out of range");
        const TO* to = storeTo[idxTo];
        m_index.insert(Element(idxFrom, idxTo, from, to, *itWgt));
      }
    }
  }
 
} // end namespace Belle2