Filter.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 <TTree.h>
#include <string>
#include <type_traits>
 
#include <tracking/trackFindingVXD/filterMap/filterFramework/VoidObserver.h>
 
namespace Belle2 {
  template<typename ... typePack>
  class Filter {
    /* Empty: just specialized templates are interesting */
  };
 
 
  template<typename ... types>
  struct all_same : std::false_type {};
 
  template<typename T>
  struct all_same<T> : std::true_type {};
 
  template< >
  struct all_same< > : std::true_type {};
 
  template<typename T, typename ... types>
  struct all_same<T, T, types ...> : all_same<T, types ...> {};
 
  class BypassableFilter;
  class ActivatableFilter;
 
 
 
  template <
    class Variable,
    class RangeType,
    class Observer
    >
  class Filter <Variable, RangeType, Observer> {
  public:
    typedef typename Variable::argumentType argumentType;
 
    typedef typename Variable::functionType functionType;
 
    explicit Filter(const RangeType& range):
      m_range(range) { };
 
    Filter() = default;
 
 
    RangeType getRange(void) const { return m_range; }
 
 
    template<typename ... argsType>
    typename std::enable_if<all_same<argumentType, argsType ... >::value, bool>::type
    accept(const argsType& ... args) const
    {
      typename Variable::variableType value = Variable::value(args ...);
      Observer::notify(Variable(), value, m_range, args ...);
      return m_range.contains(value);
    }
 
 
    void persist(TTree* t, const std::string& branchName)
    {
      m_range.persist(t, branchName, Variable().name());
    }
 
 
    void setBranchAddress(TTree* t, const std::string& branchName)
    {
      m_range.setBranchAddress(t, branchName, Variable().name());
    }
 
 
    Filter<Variable, RangeType, BypassableFilter, Observer>
    bypass(const bool& bypassVariable = false)
    {
      return Filter<Variable, RangeType, BypassableFilter, Observer>(m_range, bypassVariable);
    }
 
 
    Filter<Variable, RangeType, ActivatableFilter, Observer>
    //    __attribute__((deprecated("Please use the bypass( const bool &) method instead")))
    enable(const bool& enableVariable = true)
    {
      return Filter<Variable, RangeType, ActivatableFilter, Observer>(m_range, enableVariable);
    }
 
 
    template< class otherObserver >
    Filter<Variable, RangeType, otherObserver>
    observeLeaf(const otherObserver&) const
    {
      return Filter<Variable, RangeType, otherObserver>(m_range);
    }
 
 
    template< class otherObserver >
    Filter(const Filter<Variable, RangeType, otherObserver>& filter):
      m_range(filter.getRange()) {};
 
 
    std::string getNameAndReference(std::vector<std::pair<char, void*> >* pointers = nullptr)
    {
      return m_range.getNameAndReference(pointers, Variable::name());
    }
 
  protected:
    RangeType  m_range;
  };
 
 
 
 
  template <
    class Variable,
    class RangeType,
    class Observer
    >
  class Filter <Variable, RangeType, Belle2::BypassableFilter, Observer>:
    public Filter<Variable, RangeType, Observer> {
  public:
    typedef typename Variable::argumentType argumentType;
    typedef typename Variable::functionType functionType;
 
 
    Filter(const RangeType& range, const bool& bypass):
      Filter<Variable, RangeType, Observer>(range)
    { m_bypass = &bypass; };
 
 
    Filter() = default;
 
 
    template<typename ... argsType>
    typename std::enable_if<all_same<argumentType, argsType ...>::value, bool>::type
    accept(const argsType& ... args) const
    {
      typename Variable::variableType value = Variable::value(args ...);
      Observer::notify(Variable(), value, Filter<Variable, RangeType, Observer>::m_range, args ...);
      return (*m_bypass) || Filter<Variable, RangeType, Observer>::m_range.contains(value);
    }
 
 
    std::string getNameAndReference(std::vector<std::pair<char, void*>>* pointers = nullptr)
    {
      return "(" + std::to_string(*m_bypass) + " OR " +
             Filter<Variable, RangeType, Observer>::m_range.getNameAndReference(pointers, Variable::name()) + ")";
    }
 
  private:
    const bool* m_bypass;
  };
 
 
 
 
  template <
    class Variable,
    class RangeType,
    class Observer
    >
  class Filter <Variable, RangeType, Belle2::ActivatableFilter, Observer>:
    public Filter<Variable, RangeType, Observer> {
  public:
    typedef typename Variable::argumentType argumentType;
    typedef typename Variable::functionType functionType;
 
 
    Filter(const RangeType& range, const bool& enable):
      Filter<Variable, RangeType, Observer>(range)
    {
      m_enable = & enable ;
    };
 
 
    Filter() = default;
 
    template<typename ... argsType>
    typename std::enable_if<all_same<argumentType, argsType ...>::value, bool>::type
    accept(const argsType& ... args) const
    {
      typename Variable::variableType value = Variable::value(args ...);
      Observer::notify(Variable(), value, Filter< Variable, RangeType, Observer >::m_range,
                       args ...);
      return (!(*m_enable)) || Filter<Variable, RangeType, Observer>::m_range.contains(value);
    }
 
 
    std::string getNameAndReference(std::vector< std::pair<char, void*>>* pointers = nullptr)
    {
      return "(!(" + std::to_string(*m_enable) + ") OR "
             + Filter<Variable, RangeType, Observer>::m_range.getNameAndReference(pointers, Variable::name()) + ")";
    }
 
  private:
    const bool* m_enable;
  };
 
 
 
  class OperatorNot;
 
  template <
    class someFilter,
    class templateObserverType
    >
  class Filter <Belle2::OperatorNot, someFilter, templateObserverType> {
    const char* c_notSuffix = "_not";
  public:
    typedef typename someFilter::argumentType argumentType;
    typedef typename someFilter::functionType functionType;
 
 
    explicit Filter(const someFilter& filter):
      m_filter(filter) { };
 
 
    Filter() { };
 
 
    template<typename ... argsType>
    typename std::enable_if<all_same<argumentType, argsType ...>::value, bool>::type
    accept(const argsType& ... args) const
    {
      return ! m_filter.accept(args ...);
    }
 
 
    std::string getNameAndReference(std::vector< std::pair<char, void*>>* pointers = nullptr)
    {
      return "!" + m_filter.getNameAndReference(pointers);
    }
 
 
    template<class otherObserver>
    Filter<Belle2::OperatorNot, decltype(someFilter().observeLeaf(otherObserver())), otherObserver>
    observeLeaf(const otherObserver&) const
    {
      return Filter<Belle2::OperatorNot, decltype(someFilter().observeLeaf(otherObserver())),
             otherObserver>(m_filter.observeLeaf(otherObserver()));
    }
 
 
    void persist(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilter(branchName);
      nameOfFilter += c_notSuffix;
      m_filter.persist(t, nameOfFilter);
    }
 
 
    void setBranchAddress(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilter(branchName);
      nameOfFilter += c_notSuffix;
      m_filter.setBranchAddress(t, nameOfFilter);
    }
 
  private:
    someFilter m_filter;
  };
 
 
  template<typename ... types>
  Filter<OperatorNot, Filter<types...>, VoidObserver>
  operator !(const Filter<types...>& filter)
  {
    return Filter<OperatorNot, Filter<types...>, VoidObserver>(filter);
  }
 
 
 
  class OperatorAnd;
 
  template <
    class FilterA,
    class FilterB,
    class templateObserverType
    >
  class Filter <Belle2::OperatorAnd, FilterA, FilterB, templateObserverType> {
    const char* c_andSuffixA = "_and_A";
    const char* c_andSuffixB = "_and_B";
  public:
    typedef typename FilterA::argumentType argumentType;
    typedef typename FilterB::argumentType argumentTypeB;
    typedef typename FilterA::functionType functionTypeA;
    typedef typename FilterB::functionType functionTypeB;
    typedef typename std::enable_if<all_same<functionTypeA, functionTypeB>::value, functionTypeA>::type functionType;
 
 
    Filter(const FilterA& filterA, const FilterB& filterB):
      m_filterA(filterA), m_filterB(filterB) { };
 
 
    Filter() { };
 
 
    template<typename ... argsType>
    typename std::enable_if<all_same<argumentType, argumentTypeB, argsType ...>::value, bool>::type
    accept(const argsType& ... args) const
    {
      templateObserverType::prepare(args ...);
      bool returnValue =  m_filterA.accept(args ...) && m_filterB.accept(args ...);
      templateObserverType::collect(args ...);
      return returnValue;
    }
 
 
    template<class otherObserver>
    Filter<Belle2::OperatorAnd, decltype(FilterA().observeLeaf(otherObserver())),
           decltype(FilterB().observeLeaf(otherObserver())), otherObserver>
           observe(const otherObserver&) const
    {
      // this will recursively loop over all AND Filters and set the SAME observer
      return Filter<Belle2::OperatorAnd,
             decltype(FilterA().observeLeaf(otherObserver())),
             decltype(FilterB().observeLeaf(otherObserver())),
             otherObserver>(m_filterA.observeLeaf(otherObserver()), m_filterB.observeLeaf(otherObserver()));
    }
 
 
    template<class otherObserver>
    Filter<Belle2::OperatorAnd, decltype(FilterA().observeLeaf(otherObserver())),
           decltype(FilterB().observeLeaf(otherObserver())), VoidObserver>
           observeLeaf(const otherObserver&) const
    {
      // This will recursively loop over all lower level Filters of the AND combination and set the SAME observer.
      // For the top level filter the void observer is used.
      return Filter<Belle2::OperatorAnd,
             decltype(FilterA().observeLeaf(otherObserver())),
             decltype(FilterB().observeLeaf(otherObserver())),
             VoidObserver>(m_filterA.observeLeaf(otherObserver()), m_filterB.observeLeaf(otherObserver()));
    }
 
 
    void persist(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilterA(branchName);
      nameOfFilterA += c_andSuffixA;
      m_filterA.persist(t, nameOfFilterA);
 
      std::string nameOfFilterB(branchName);
      nameOfFilterB += c_andSuffixB;
      m_filterB.persist(t, nameOfFilterB);
    }
 
 
    void setBranchAddress(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilterA(branchName);
      nameOfFilterA += c_andSuffixA;
      m_filterA.setBranchAddress(t, nameOfFilterA);
 
      std::string nameOfFilterB(branchName);
      nameOfFilterB += c_andSuffixB;
      m_filterB.setBranchAddress(t, nameOfFilterB);
    }
 
 
    std::string getNameAndReference(std::vector< std::pair<char, void*>>* pointers = nullptr)
    {
      return "(" + m_filterA.getNameAndReference(pointers) + " AND " + m_filterB.getNameAndReference(pointers) + ")";
    }
 
  private:
    FilterA m_filterA;
    FilterB m_filterB;
  };
 
 
  template <
    typename ... types1,
    typename ... types2
    >
  Filter<Belle2::OperatorAnd, Belle2::Filter<types1...>, Belle2::Filter<types2...>, Belle2::VoidObserver>
  operator &&(const Filter<types1...>& filter1, const Filter<types2...>& filter2)
  {
    return Filter<OperatorAnd, Filter<types1...>, Filter<types2...>, VoidObserver> (filter1, filter2);
  }
 
 
 
  class OperatorOr;
 
  template <
    class FilterA,
    class FilterB,
    class templateObserverType
    >
  // cppcheck-suppress copyCtorAndEqOperator
  class Filter <Belle2::OperatorOr, FilterA, FilterB, templateObserverType > {
    const char* c_orSuffixA = "_or_A";
    const char* c_orSuffixB = "_or_B";
 
  public:
    typedef typename FilterA::argumentType argumentType;
    typedef typename FilterB::argumentType argumentTypeB;
    typedef typename FilterA::functionType functionTypeA;
    typedef typename FilterB::functionType functionTypeB;
    typedef typename std::enable_if<all_same<functionTypeA, functionTypeB>::value, functionTypeA>::type functionType;
 
 
    Filter(const FilterA& filterA, const FilterB& filterB):
      m_filterA(filterA), m_filterB(filterB) { };
 
 
    Filter() { };
 
 
    template<typename ... argsType>
    typename std::enable_if <all_same<argumentType, argumentTypeB, argsType ...>::value, bool>::type
    accept(const argsType& ... args) const
    {
      templateObserverType::prepare(args ...);
      bool returnValue =  m_filterA.accept(args ...) || m_filterB.accept(args ...);
      templateObserverType::collect(args ...);
      return returnValue;
    }
 
 
    template<class otherObserver>
    Filter<Belle2::OperatorOr, decltype(FilterA().observeLeaf(otherObserver())),
           decltype(FilterB().observeLeaf(otherObserver())), otherObserver>
           observe(const otherObserver&) const
    {
      // this will recursively loop over all "and" Filters and set the SAME observer
      return Filter<Belle2::OperatorOr,
             decltype(FilterA().observeLeaf(otherObserver())),
             decltype(FilterB().observeLeaf(otherObserver())),
             otherObserver>(m_filterA.observeLeaf(otherObserver()), m_filterB.observeLeaf(otherObserver()));
    }
 
 
    template<class otherObserver>
    Filter<Belle2::OperatorOr, decltype(FilterA().observeLeaf(otherObserver())),
           decltype(FilterB().observeLeaf(otherObserver())), VoidObserver>
           observeLeaf(const otherObserver&) const
    {
      // This will recursively loop over all lower level Filters of the AND combination and set the SAME observer.
      // For the top level filter the void observer is used.
      return Filter<Belle2::OperatorOr,
             decltype(FilterA().observeLeaf(otherObserver())),
             decltype(FilterB().observeLeaf(otherObserver())),
             VoidObserver>(m_filterA.observeLeaf(otherObserver()), m_filterB.observeLeaf(otherObserver()));
    }
 
 
    void persist(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilterA(branchName);
      nameOfFilterA += c_orSuffixA;
      m_filterA.persist(t, nameOfFilterA);
 
      std::string nameOfFilterB(branchName);
      nameOfFilterB += c_orSuffixB;
      m_filterB.persist(t, nameOfFilterB);
    }
 
 
    void setBranchAddress(TTree* t, const std::string& branchName)
    {
      std::string nameOfFilterA(branchName);
      nameOfFilterA += c_orSuffixA;
      m_filterA.setBranchAddress(t, nameOfFilterA);
 
      std::string nameOfFilterB(branchName);
      nameOfFilterB += c_orSuffixB;
      m_filterB.setBranchAddress(t, nameOfFilterB);
    }
 
 
    std::string getNameAndReference(std::vector< std::pair<char, void*>>* pointers = nullptr)
    {
      return "(" + m_filterA.getNameAndReference(pointers) + " OR " + m_filterB.getNameAndReference(pointers) + ")";
    }
 
  private:
    FilterA  m_filterA;
    FilterB  m_filterB;
  };
 
 
  template <
    typename ... types1,
    typename ... types2
    >
  Filter<Belle2::OperatorOr, Belle2::Filter<types1...>, Belle2::Filter<types2...>, Belle2::VoidObserver>
  operator ||(const Filter<types1...>& filter1, const Filter<types2...>& filter2)
  {
    return Filter<OperatorOr, Filter<types1...>, Filter<types2...>, VoidObserver> (filter1, filter2);
  }
 
 
 
 
  template<class booleanBinaryOperator,
           typename ... types1,
           typename ... types2,
           class observer,
           typename ... argsTypes>
  bool initializeObservers(const Filter<booleanBinaryOperator, Belle2::Filter<types1...>,
                           Belle2::Filter<types2...>, observer>&,
                           argsTypes ... args)
  {
    return observer::initialize(args ...)
           && initializeObservers(Belle2::Filter<types1...>(), args...)
           && initializeObservers(Belle2::Filter<types2...>(), args ...);
  }
 
 
  template<class booleanUnaryOperator,
           typename ... types1,
           class observer,
           typename ... argsTypes>
  bool initializeObservers(const Filter<booleanUnaryOperator, Belle2::Filter<types1...>, observer>&, argsTypes ... args)
  {
    return observer::initialize(args ...) && initializeObservers(Belle2::Filter<types1...>(), args...);
  }
 
 
  template<class Variable, class RangeType, class observer, typename ... argsTypes>
  bool initializeObservers(const Belle2::Filter<Variable, RangeType, observer>& filter, argsTypes ... args)
  {
    return observer::initialize(Variable(), filter.getRange(), args ...);
  }
}