WithWeightedItems.h

/**************************************************************************
* BASF2 (Belle Analysis Framework 2)                                     *
* Copyright(C) 2015 - Belle II Collaboration                             *
*                                                                        *
* Author: The Belle II Collaboration                                     *
* Contributors: Oliver Frost                                             *
*                                                                        *
* This software is provided "as is" without any warranty.                *
**************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/numerics/WithWeight.h>
 
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    template <class T, class AItem>
    class WithWeightedItems : public T {
 
    private:
      using Super = T;
 
      using This = WithWeightedItems<T, AItem>;
 
    public:
      using T::T;
 
      using T::operator=;
 
      explicit WithWeightedItems(const T& t)
        : T(t)
      {
      }
 
      Weight getWeight() const
      {
        return std::accumulate(begin(),
                               end(),
                               static_cast<Weight>(0.0),
        [](Weight accumulatedWeight, const WithWeight<AItem>& weightedItem) {
          return accumulatedWeight + weightedItem.getWeight();
        });
      }
 
      template <class APredicate>
      void eraseIf(const APredicate& predicate)
      {
        // Sneakily hide the items instead of erasing them.
        // auto notPredicate = [&predicate](AItem & item) { return not predicate(item); };
        // m_itEnd = std::partition(m_items.begin(), m_items.end(), notPredicate);
        // Properly delete use the following.
        m_itEnd = std::remove_if(m_items.begin(), m_items.end(), predicate);
        m_items.erase(m_itEnd, m_items.end());
      }
 
      void insert(const AItem& item, Weight weight = 1.0)
      {
        m_itEnd = m_items.insert(end(), WithWeight<AItem>(item));
        m_itEnd->setWeight(weight);
        ++m_itEnd;
      }
 
      template <class AMeasure>
      void insert(const This& items, AMeasure& measure)
      {
        for (AItem item : items.m_items) {
          const Weight weight = measure(item);
          if (not std::isnan(weight)) {
            insert(item, weight);
          }
        }
      }
 
      typename std::vector<WithWeight<AItem>>::iterator begin()
      {
        return m_items.begin();
      }
 
      typename std::vector<WithWeight<AItem>>::const_iterator begin() const
      {
        return m_items.begin();
      }
 
      typename std::vector<WithWeight<AItem>>::iterator end()
      {
        return m_itEnd;
      }
 
      typename std::vector<WithWeight<AItem>>::const_iterator end() const
      {
        return m_itEnd;
      }
 
      size_t size() const
      {
        return std::distance(begin(), end());
      }
 
    public:
      void clear()
      {
        m_items.clear();
        m_itEnd = m_items.end();
        Super& super = *this;
        clearIfApplicable(super);
      }
 
    private:
      std::vector<WithWeight<AItem>> m_items;
 
      typename std::vector<WithWeight<AItem>>::iterator m_itEnd{m_items.end()};
    };
  }
}