WithWeightedItems.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 <tracking/trackingUtilities/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)
      {
      }

      TrackingUtilities::Weight getWeight() const
      {
        return m_weightSum;
      }

      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);
        if (m_itEnd != m_items.end()) {
          m_items.erase(m_itEnd, m_items.end());
          // Recompute the cumulated weight in the same order as a fresh accumulation
          m_weightSum = std::accumulate(begin(),
                                        end(),
                                        static_cast<TrackingUtilities::Weight>(0.0),
          [](TrackingUtilities::Weight accumulatedWeight, const TrackingUtilities::WithWeight<AItem>& weightedItem) {
            return accumulatedWeight + weightedItem.getWeight();
          });
        }
      }

      void insert(const AItem& item, TrackingUtilities::Weight weight = 1.0)
      {
        // The end marker always coincides with the end of the item vector, hence append.
        m_items.emplace_back(item, weight);
        m_itEnd = m_items.end();
        m_weightSum += weight;
      }

      template <class AMeasure>
      void insert(const This& items, AMeasure& measure)
      {
        for (AItem item : items.m_items) {
          const TrackingUtilities::Weight weight = measure(item);
          if (not std::isnan(weight)) {
            insert(item, weight);
          }
        }
      }

      typename std::vector<TrackingUtilities::WithWeight<AItem>>::iterator begin()
      {
        return m_items.begin();
      }

      typename std::vector<TrackingUtilities::WithWeight<AItem>>::const_iterator begin() const
      {
        return m_items.begin();
      }

      typename std::vector<TrackingUtilities::WithWeight<AItem>>::iterator end()
      {
        return m_itEnd;
      }

      typename std::vector<TrackingUtilities::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();
        m_weightSum = 0.0;
        Super& super = *this;
        TrackingUtilities::clearIfApplicable(super);
      }
 
    private:
      std::vector<TrackingUtilities::WithWeight<AItem>> m_items;

      typename std::vector<TrackingUtilities::WithWeight<AItem>>::iterator m_itEnd{m_items.end()};

      TrackingUtilities::Weight m_weightSum = 0.0;
    };
  }
}