RelationVector.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Kuhr                                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationEntry.h>
#include <framework/utilities/ArrayIterator.h>
 
#include <vector>
#include <string>
#include <functional>
 
namespace Belle2 {
  class RelationVectorBase {
  public:
    RelationVectorBase() { }
 
    RelationVectorBase(const std::string& name, int index, const std::vector<Belle2::RelationEntry>& relations,
                       const std::vector<std::string>& names): m_name(name), m_index(index), m_relations(relations), m_relationNames(names) {}
 
  protected:
    void add(const RelationVectorBase& other);
 
    void apply(int index, const std::function<void(std::vector<unsigned int>&, std::vector<float>&, size_t)>& f);
 
    std::string m_name; 
    int m_index{ -1}; 
    std::vector<RelationEntry> m_relations;  
    std::vector<std::string> m_relationNames;  
    friend class DataStore;
  };
 
  template <class T> class RelationVector : protected RelationVectorBase {
  public:
    typedef ArrayIterator<RelationVector<T>, T> iterator;
    typedef ArrayIterator<RelationVector<T>, const T> const_iterator;
 
 
    explicit RelationVector(const RelationVectorBase& b): RelationVectorBase(b) {}
 
    const std::vector<Belle2::RelationEntry>& relations() const {return m_relations;}
 
    size_t size() const { return m_relations.size();}
 
 
    T*     object(int index) const {return static_cast<T*>(m_relations[index].object);}
 
    T*     operator[](int index) const {return object(index);}
 
    float weight(int index) const {return m_relations[index].weight;}
 
    void remove(int index)
    {
      apply(index, [](std::vector<unsigned int>& indices, std::vector<float>& weights,
      size_t elidx) {
        indices.erase(indices.begin() + elidx);
        weights.erase(weights.begin() + elidx);
      });
 
      m_relations.erase(m_relations.begin() + index);
    }
 
    void setWeight(int index, float weight)
    {
      apply(index, [weight](std::vector<unsigned int>&, std::vector<float>& weights, size_t elidx) {
        weights[elidx] = weight;
      });
 
      m_relations[index].weight = weight;
    }
 
    iterator begin() { return iterator(this, 0); }
    iterator end() { return iterator(this, size()); }
 
    const_iterator begin() const { return const_iterator(this, 0); }
    const_iterator end() const { return const_iterator(this, size()); }
  };
}