RelationArray.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/DataStore.h>
#include <framework/datastore/StoreAccessorBase.h>
#include <framework/utilities/ArrayIterator.h>
#include <framework/dataobjects/RelationElement.h>
#include <framework/dataobjects/RelationContainer.h>
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  template <class T> class StoreArray;

  class RelationArray: public StoreAccessorBase {
  public:
    typedef ObjArrayIterator<const TClonesArray, const RelationElement> const_iterator;

    typedef RelationElement::index_type index_type;

    typedef RelationElement::weight_type weight_type;

    enum EConsolidationAction {
      c_doNothing, 
      c_negativeWeight, 
      c_zeroWeight, 
      c_deleteElement 
    };

    typedef std::pair<index_type, bool> consolidation_type;

    struct Identity {
      consolidation_type operator()(index_type old) const { return std::make_pair(old, false); }
    };

    template < class MapType = std::map<index_type, consolidation_type> > class ReplaceMap {
    public:

      explicit ReplaceMap(MapType& replace): m_replace(replace) {}

      consolidation_type operator()(index_type old) const
      {
        typename MapType::const_iterator iter = m_replace.find(old);
        if (iter != m_replace.end()) {
          return iter->second;
        }
        return std::make_pair(old, false);
      }
 
    private:

      MapType& m_replace;
    };
 

    template < class VecType = std::vector<consolidation_type> > class ReplaceVec {
    public:

      explicit ReplaceVec(VecType& replace): m_replace(replace) {}

      consolidation_type operator()(index_type old) const { return m_replace[old];  }
 
    private:

      VecType& m_replace;
    };
 

    bool create(bool replace = false)
    {
      bool result = DataStore::Instance().createObject(0, replace, *this);
      m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (result) {
        (*m_relations)->setFromName(m_accessorFrom.first);
        (*m_relations)->setFromDurability(m_accessorFrom.second);
        (*m_relations)->setToName(m_accessorTo.first);
        (*m_relations)->setToDurability(m_accessorTo.second);
      }
      return result;
    }

    template <class FROM, class TO> RelationArray(const StoreArray<FROM>& from, const StoreArray<TO>& to, const std::string& name = "",
                                                  DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(name.empty() ? DataStore::relationName(from.getName(), to.getName()) : name, durability,
                        RelationContainer::Class(), false),
      m_accessorFrom(from.getAccessorParams()),
      m_accessorTo(to.getAccessorParams()),
      m_relations(0)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        B2FATAL("Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates");
      }
    }

    RelationArray(const AccessorParams& fromAccessor, const AccessorParams& toAccessor,
                  DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(DataStore::relationName(fromAccessor.first, toAccessor.first), durability, RelationContainer::Class(), false),
      m_accessorFrom(fromAccessor),
      m_accessorTo(toAccessor),
      m_relations(nullptr)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        B2FATAL("Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates");
      }
    }

    explicit RelationArray(const std::string& name, DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(name, durability, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (name.empty()) {
        B2FATAL("Cannot guess relation name, please supply correct name");
      }
    }

    ~RelationArray() {}

    inline bool isValid() const { ensureAttached(); return m_relations && *m_relations;}
    inline operator bool()  const { return isValid(); }

    const RelationElement& operator[](int i) const { assertValid(); return (*m_relations)->getElement(i);}

    int getEntries() const { return isValid() ? ((*m_relations)->getEntries()) : 0; }

    const AccessorParams& getFromAccessorParams() const
    {
      ensureAttached();
      if (m_accessorFrom.first.empty())
        B2FATAL("trying to get accessor params from non-existing relation (this is likely a framework bug)");
      return m_accessorFrom;
    }

    const AccessorParams& getToAccessorParams() const
    {
      ensureAttached();
      if (m_accessorTo.first.empty())
        B2FATAL("trying to get accessor params from non-existing relation (this is likely a framework bug)");
      return m_accessorTo;
    }

    bool getModified() const { assertValid(); return (*m_relations)->getModified(); }

    void setModified(bool modified) { assertCreated(); (*m_relations)->setModified(modified); }

    void clear() override
    {
      setModified(true);
      (*m_relations)->elements().Delete();
    }

    void add(index_type from, index_type to, weight_type weight = 1.0)
    {
      setModified(true);
      new (next()) RelationElement(from, to, weight);
    }

    void add(index_type from, const std::vector<index_type>& to, weight_type weight = 1.0)
    {
      setModified(true);
      std::vector<weight_type> weights(to.size(), weight);
      new (next()) RelationElement(from, to, weights);
    }

    void add(index_type from, const std::vector<index_type>& to, const std::vector<weight_type>& weights)
    {
      setModified(true);
      new (next()) RelationElement(from, to, weights);
    }

    template <class InputIterator> void add(index_type from, const InputIterator& begin, const InputIterator& end)
    {
      setModified(true);
      new (next()) RelationElement(from, begin, end);
    }

    void consolidate() { consolidate<Identity, Identity>(); }

    template<class FunctionFrom, class FunctionTo> void consolidate(const
        FunctionFrom& replaceFrom = FunctionFrom(), const FunctionTo &
        replaceTo = FunctionTo(), EConsolidationAction action =
          c_doNothing);

    const_iterator begin() const { assertValid(); return const_iterator((*m_relations)->elements(), 0); }
    const_iterator end() const { assertValid(); return const_iterator((*m_relations)->elements(), getEntries()); }
 
  private:
    explicit RelationArray(const AccessorParams& params):
      StoreAccessorBase(params.first, params.second, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (params.first.empty()) {
        B2FATAL("Cannot guess relation name, please supply correct name");
      }
    }
 

    RelationElement* next()
    {
      int index = (*m_relations)->elements().GetLast() + 1;
      return static_cast<RelationElement*>((*m_relations)->elements().AddrAt(index));
    }

    void checkRelation(const std::string& direction, const AccessorParams& array, const AccessorParams& rel) const
    {
      if (array.second == 0 && array.first.empty())
        return; //no information to check against...
 
      if (array != rel) {
        B2FATAL("Relation '" << m_name << "' exists but points " << direction << " wrong array:"
                << " requested " << array.first << "(" << array.second << ")"
                << ", got " << rel.first << "(" << rel.second << ")"
               );
      }
    }

    void ensureAttached() const
    {
      if (m_relations)
        return;
 
      const_cast<RelationArray*>(this)->m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (m_relations && *m_relations && !(*m_relations)->isDefaultConstructed()) {
        AccessorParams fromAccessorRel((*m_relations)->getFromName(), (DataStore::EDurability)(*m_relations)->getFromDurability());
        AccessorParams toAccessorRel((*m_relations)->getToName(), (DataStore::EDurability)(*m_relations)->getToDurability());
        //set if unset
        if (m_accessorFrom.first.empty())
          const_cast<RelationArray*>(this)->m_accessorFrom = fromAccessorRel;
        if (m_accessorTo.first.empty())
          const_cast<RelationArray*>(this)->m_accessorTo = toAccessorRel;
        checkRelation("from", m_accessorFrom, fromAccessorRel);
        checkRelation("to", m_accessorTo, toAccessorRel);
      } else {
        //no relation found, mark as invalid
        const_cast<RelationArray*>(this)->m_relations = nullptr;
      }
    }

    void assertValid() const { if (!isValid()) B2FATAL("RelationArray does not point to valid StoreObject"); }

    void assertCreated()
    {
      if (!isValid()) {
        if (!create()) {
          B2FATAL("Couldn't create relation " << m_name << "!");
        }
      }
    }

    AccessorParams m_accessorFrom;

    AccessorParams m_accessorTo;

    RelationContainer** m_relations;
 
    template<class FROM, class TO> friend class RelationIndex;
    template<class FROM, class TO> friend class RelationIndexContainer;
 
  };
 
  template<class FunctionFrom, class FunctionTo>
  void RelationArray::consolidate(const FunctionFrom& replaceFrom, const FunctionTo& replaceTo, EConsolidationAction action)
  {
    if (!isValid()) {
      B2ERROR("Cannot consolidate an invalid relation (" << m_name << ")");
      return;
    }
    typedef std::map<index_type, weight_type> element_t;
    typedef std::map<index_type, element_t > buffer_t;
    buffer_t buffer;
 
    //Fill all existing elements in a nested map, adding the weights of
    //duplicate elements
    index_type lastFromIndex(0);
    buffer_t::iterator lastFromIter = buffer.end();
    unsigned int nElements = (*m_relations)->getEntries();
    TClonesArray& elements = (*m_relations)->elements();
    for (unsigned int i = 0; i < nElements; ++i) {
      RelationElement& element = *static_cast<RelationElement*>(elements[i]);
      //Replace from index
      consolidation_type from = replaceFrom(element.getFromIndex());
 
      //Ignore whole element if original element got deleted
      if (action == c_deleteElement && from.second) continue;
 
      //Check if the fromIndex is the same as the last one and reuse
      //iterator if possible
      if (from.first != lastFromIndex || lastFromIter == buffer.end()) {
        lastFromIter = buffer.insert(make_pair(from.first, element_t())).first;
        lastFromIndex = from.first;
      }
      //Loop over all elements of this relationelement and add them to the map
      size_t size = element.getSize();
      for (size_t j = 0; j < size; ++j) {
        //Replace to Index
        consolidation_type to = replaceTo(element.getToIndex(j));
        //Ignore whole element if original element got deleted
        if (action == c_deleteElement && to.second) continue;
        double weight = element.getWeight(j);
        //Original from or to element got deleted. Do whatever is specified by action
        //Warning: if there is more than one element pointing to the same
        //from->to element after transformation the negative weight option is
        //not safe as we sum a positive and a negative weight when
        //consolidating.
        if (from.second || to.second) {
          if (action == c_zeroWeight) {
            weight = 0;
          } else if (action == c_negativeWeight && weight > 0) {
            weight = -weight;
          }
        }
        //add the weight to the new from->to index pair
        lastFromIter->second[to.first] += weight;
      }
    }
    //Clear the existing relation
    elements.Delete();
    //Fill the map into the relation
    for (buffer_t::iterator iter = buffer.begin(); iter != buffer.end(); ++iter) {
      add(iter->first, iter->second.begin(), iter->second.end());
    }
  }

} // end namespace Belle2