WeightedRelation.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/Weight.h>
 
#include <algorithm>
#include <utility>
#include <type_traits>
#include <cassert>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template <class AFrom, class ATo = AFrom>
    class WeightedRelation : public std::pair<std::pair<AFrom*, Weight>, ATo*> {
 
      using Super = std::pair<std::pair<AFrom*, Weight>, ATo*>;
 
    public:
      using From = AFrom;
 
      using To = ATo;
 
    public:
      WeightedRelation() = default;
 
      WeightedRelation(From* from, Weight weight, To* to)
        : Super( {from, weight}, to)
      {}
 
      bool operator<(const WeightedRelation<From, To>& rhs) const
      {
        return (getFrom() < rhs.getFrom() or
                (not(rhs.getFrom() < getFrom()) and
                 // highest weight first
                 (getWeight() > rhs.getWeight() or
                  (not(rhs.getWeight() > getWeight()) and
                   (getTo() < rhs.getTo())))));
      }
 
      friend bool operator<(const std::pair<From*, Weight>& weightedPtr,
                            const WeightedRelation<From, To>& weightedRelation)
      {
        return (weightedPtr.first < weightedRelation.getFrom() or
                (not(weightedRelation.getFrom() < weightedPtr.first) and
                 // highest weight first
                 (weightedPtr.second > weightedRelation.getWeight())));
      }
 
      friend bool operator<(const WeightedRelation<From, To>& weightedRelation,
                            const std::pair<From*, Weight>& weightedPtr)
      {
        return (weightedRelation.getFrom() < weightedPtr.first or
                (not(weightedPtr.first < weightedRelation.getFrom()) and
                 // highest weight first
                 (weightedRelation.getWeight() > weightedPtr.second)));
      }
 
      friend bool operator<(const From* ptrFrom, const WeightedRelation<From, To>& weightedRelation)
      {
        return ptrFrom < weightedRelation.getFrom();
      }
 
      friend bool operator<(const WeightedRelation<From, To>& weightedRelation, const From* ptrFrom)
      {
        return weightedRelation.getFrom() < ptrFrom;
      }
 
      From* getFrom() const
      {
        return getWeightedFrom().first;
      }
 
      Weight getWeight() const
      {
        return getWeightedFrom().second;
      }
 
      void setWeight(Weight weight)
      {
        this->first.second = weight;
      }
 
      const std::pair<From*, Weight>& getWeightedFrom() const
      {
        return this->first;
      }
 
      To* getTo() const
      {
        return this->second;
      }
 
      WeightedRelation<To, From> reversed() const
      {
        //return WeightedRelation<To, From>(getTo(), getWeight(), getFrom());
        return {getTo(), getWeight(), getFrom()};
      }
    };
 
    template <class AFrom, class ATo = AFrom>
    struct WeightedRelationUtil {
      template <class AWeightedRelations>
      static bool areSymmetric(const AWeightedRelations& weightedRelations)
      {
        static_assert(std::is_same<AFrom, ATo>::value, "Symmetric check requires some types in From and To");
        assert(std::is_sorted(std::begin(weightedRelations), std::end(weightedRelations)));
        auto reversedRelationExists =
        [&weightedRelations](const WeightedRelation<AFrom, ATo>& weightedRelation) -> bool {
          auto reversedRelations = std::equal_range(std::begin(weightedRelations),
          std::end(weightedRelations),
          weightedRelation.reversed());
          return reversedRelations.first != reversedRelations.second;
        };
        return std::all_of(std::begin(weightedRelations),
                           std::end(weightedRelations),
                           reversedRelationExists);
      }
    };
  }
}