Functional.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - 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/utilities/FunctorTag.h>
 
#include <type_traits>
#include <utility>
#include <cassert>
#include <cmath>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    struct Id {
      operator FunctorTag();
 
      template <class T>
      T&& operator()(T&& t) const
      {
        return std::forward<T>(t);
      }
    };
 
    template<class T>
    struct Constant {
      operator FunctorTag();
 
      Constant() = default;
 
      explicit Constant(const T& t)
        : m_t(t)
      {
      }
 
      template <class S>
      constexpr const T& operator()(const S&) const
      {
        return m_t;
      }
 
    private:
      T m_t{};
    };
 
 
 
    template<class T, class SFINAE = std::enable_if_t<not isFunctor<T>()> >
    constexpr Constant<T> toFunctor(const T& t)
    {
      return Constant<T> {t};
    }
 
    template<class AFunctor, class SFINAE = std::enable_if_t<isFunctor<AFunctor>()> >
    constexpr const AFunctor & toFunctor(const AFunctor& get)
    {
      return get;
    }
 
    template <class T>
    using ToFunctor = typename std::decay<decltype(toFunctor(std::declval<T>()))>::type;
 
 
 
    template <class AFunctor1, class AFunctor2>
    struct Composition {
      operator FunctorTag();
 
      Composition() = default;
 
      explicit Composition(const AFunctor2& functor2)
        : m_functor1()
        , m_functor2(functor2)
      {
      }
 
      Composition(const AFunctor1& functor1, const AFunctor2& functor2)
        : m_functor1(functor1)
        , m_functor2(functor2)
      {
      }
 
    private: // Members here for lookup reasons
      AFunctor1 m_functor1;
 
      AFunctor2 m_functor2;
 
    public:
      template<class T>
      auto operator()(const T& t) const -> decltype(m_functor1(m_functor2(t)))
      {
        return m_functor1(m_functor2(t));
      }
    };
 
    template <class ABinaryOp, class AFunctor1, class AFunctor2 = AFunctor1>
    struct BinaryJoin : public ABinaryOp {
    public:
      operator FunctorTag();
 
      BinaryJoin() = default;
 
      BinaryJoin(const ABinaryOp& binaryOp, const AFunctor1& functor1, const AFunctor2& functor2)
        : m_binaryOp(binaryOp)
        , m_functor1(functor1)
        , m_functor2(functor2)
      {
      }
 
 
      BinaryJoin(const AFunctor1& functor1, const AFunctor2& functor2)
        : m_binaryOp()
        , m_functor1(functor1)
        , m_functor2(functor2)
      {
      }
 
    private: // Members here for lookup reasons
      ABinaryOp m_binaryOp;
 
      AFunctor1 m_functor1;
 
      AFunctor2 m_functor2;
 
    public:
      template <class T1, class T2>
      auto operator()(const T1& t1, const T2& t2) const -> decltype(m_binaryOp(m_functor1(t1), m_functor2(t2)))
      {
        return m_binaryOp(m_functor1(t1), m_functor2(t2));
      }
 
      template <class T>
      auto operator()(const T& t) const -> decltype(m_binaryOp(m_functor1(t), m_functor2(t)))
      {
        return m_binaryOp(m_functor1(t), m_functor2(t));
      }
    };
 
    template <class AFunctor1, class AFunctor2>
    struct Alternation {
 
    public:
      operator FunctorTag();
 
    private: // Members first for lookup reasons
      AFunctor1 m_functor1;
 
      AFunctor2 m_functor2;
 
    public:
      Alternation() = default;
 
      Alternation(const AFunctor1& functor1, const AFunctor2& functor2 = AFunctor2())
        : m_functor1(functor1)
        , m_functor2(functor2)
      {
      }
 
    public:
      template <class... T>
      auto impl(int favouredTag __attribute__((unused)), T&& ... t) const
      -> decltype(m_functor1(std::forward<T>(t)...))
      {
        return m_functor1(std::forward<T>(t)...);
      }
 
      template <class... T>
      auto impl(long disfavouredTag __attribute__((unused)), T&& ... t) const
      -> decltype(m_functor2(std::forward<T>(t)...))
      {
        return m_functor2(std::forward<T>(t)...);
      }
 
    public:
      template <class... T>
      auto operator()(T&& ... t) const -> decltype(this->impl(0, std::forward<T>(t)...))
      {
        int dispatchTag = 0;
        return impl(dispatchTag, std::forward<T>(t)...);
      }
    };
 
 
    // ******************** (void)(?) ********************
 
    struct Void {
      operator FunctorTag();
 
      template <class T>
      void operator()(T&& t __attribute__((unused))) const
      {
      }
    };
 
    template <class AFunctor = Id>
    using VoidOf = Composition<Void, AFunctor>;
 
    template <class AFunctor>
    using IfApplicable = Alternation<AFunctor, Void>;
 
    template<class AFunction, class... T>
    void invokeIfApplicable(AFunction&& function, T&& ... t)
    {
      IfApplicable<AFunction> invokeIfApplicableImpl(std::forward<AFunction>(function));
      invokeIfApplicableImpl(std::forward<T>(t)...);
    }
 
    template<class ADefault, class AFunctor, class T>
    ADefault getIfApplicable(AFunctor&& function, T&& obj, ADefault value)
    {
      Alternation<AFunctor, Constant<ADefault> > getIfApplicableImpl{std::forward<AFunctor>(function), Constant(value) };
      return getIfApplicableImpl(std::forward<T>(obj));
    }
 
 
    // ******************** get<I>(?) ********************
 
    template<int I>
    struct Get {
      operator FunctorTag();
 
      template <class T>
      auto operator()(const T& t) const -> decltype(std::get<I>(t))
      {
        using std::get;
        return get<I>(t);
      }
    };
 
    template <int I, class AFunctor = Id>
    using GetOf = Composition<Get<I>, AFunctor>;
 
 
    // ******************** ?.first ********************
 
    using First = Get<0>;
 
    template<class AFunctor = Id>
    using FirstOf = GetOf<0, AFunctor>;
 
 
    // ******************** ?.second ********************
 
    using Second = Get<1>;
 
    template<class AFunctor = Id>
    using SecondOf = GetOf<1, AFunctor>;
 
 
    // ******************** ?.size() ********************
 
    struct Size {
      operator FunctorTag();
 
      template <class T>
      auto operator()(const T& t) const -> decltype(t.size())
      {
        return t.size();
      }
    };
 
    template <class AFunctor = Id>
    using SizeOf = Composition<Size, AFunctor>;
 
 
    // ******************** ?.clear() ********************
 
    struct Clear {
      operator FunctorTag();
 
      template <class T>
      auto operator()(T& t) const -> decltype(t.clear())
      {
        return t.clear();
      }
    };
 
    template <class AFunctor = Id>
    using ClearOf = Composition<Clear, AFunctor>;
 
    using ClearIfApplicable = IfApplicable<Clear>;
 
    static const ClearIfApplicable clearIfApplicable{};
 
    // ******************** not(?) ********************
 
    struct Not {
      operator FunctorTag();
 
      template <class T>
      auto operator()(const T& t) const -> decltype(not t)
      {
        return not t;
      }
    };
 
    template <class AFunctor = Id>
    using NotOf = Composition<Not, AFunctor>;
 
    template <class AFunctor, class SFINAE = std::enable_if_t<isFunctor<AFunctor>()> >
    NotOf<AFunctor> operator!(const AFunctor& functor)
    {
      return NotOf<AFunctor> {functor};
    }
 
 
    // ******************** *? ********************
 
    struct Deref {
      operator FunctorTag();
 
      template <class T>
      auto operator()(const T& t) const -> decltype(*t)
      {
        return *t;
      }
 
      template <class T>
      auto operator()(const T* t) const -> decltype(*t)
      {
        assert(t != nullptr);
        return *t;
      }
    };
 
    template <class AFunctor = Id>
    using DerefOf = Composition<Deref, AFunctor>;
 
    template <class AFunctor = Id>
    using DerefTo = Composition<AFunctor, Deref>;
 
    // ******************** *(?->) ********************
 
    struct Indirect {
      operator FunctorTag();
 
      template <class T>
      auto operator()(const T& t) const -> decltype(*(t.operator->()))
      {
        assert(t.operator->() != nullptr);
        return *(t.operator->());
      }
 
      template <class T>
      const T& operator()(const T* t) const
      {
        assert(t != nullptr);
        return *t;
      }
    };
 
    template <class AFunctor = Id>
    using IndirectOf = Composition<Indirect, AFunctor>;
 
    template <class AFunctor = Id>
    using IndirectTo = Composition<AFunctor, Indirect>;
 
    template <class AFunctor>
    using MayIndirectTo = Alternation<IndirectTo<AFunctor>, AFunctor>;
    // using MayIndirectTo = AFunctor;
 
    // ******************** ? < ? aka less ********************
 
    struct Less {
      operator FunctorTag();
 
      template<class T1, class T2>
      auto operator()(const T1& t1, const T2& t2) const -> decltype(t1 < t2)
      {
        return t1 < t2;
      }
    };
 
    template <class AFunctor1 = Id, class AFunctor2 = AFunctor1>
    using LessOf = BinaryJoin<Less, AFunctor1, AFunctor2>;
 
    template <class ALHS, class ARHS, class SFINAE = std::enable_if_t<isFunctor<ALHS>() or isFunctor<ARHS>()>>
    LessOf<ToFunctor<ALHS>, ToFunctor<ARHS> > operator<(const ALHS& lhs, const ARHS& rhs)
    {
      return {toFunctor(lhs), toFunctor(rhs)};
    }
 
 
 
    // ******************** ? > ? aka greater ********************
 
    struct Greater {
      operator FunctorTag();
 
      template<class T1, class T2>
      auto operator()(const T1& t1, const T2& t2) const -> decltype(t1 > t2)
      {
        return t1 > t2;
      }
    };
 
    template <class AFunctor1 = Id, class AFunctor2 = AFunctor1>
    using GreaterOf = BinaryJoin<Greater, AFunctor1, AFunctor2>;
 
    template <class ALHS, class ARHS, class SFINAE = std::enable_if_t<isFunctor<ALHS>() or isFunctor<ARHS>()>>
    GreaterOf<ToFunctor<ALHS>, ToFunctor<ARHS> > operator>(const ALHS& lhs, const ARHS& rhs)
    {
      return {toFunctor(lhs), toFunctor(rhs)};
    }
 
    // ******************** ? == ? aka equal_to ********************
 
    struct Equal {
      operator FunctorTag();
 
      template<class T1, class T2>
      auto operator()(const T1& t1, const T2& t2) const -> decltype(t1 == t2)
      {
        return t1 == t2;
      }
    };
 
    template <class AFunctor1 = Id, class AFunctor2 = AFunctor1>
    using EqualOf = BinaryJoin<Equal, AFunctor1, AFunctor2>;
 
    template <class ALHS, class ARHS, class SFINAE = std::enable_if_t<isFunctor<ALHS>() or isFunctor<ARHS>()>>
    EqualOf<ToFunctor<ALHS>, ToFunctor<ARHS> > operator==(const ALHS& lhs, const ARHS& rhs)
    {
      return {toFunctor(lhs), toFunctor(rhs)};
    }
 
    struct IsNaN {
      operator FunctorTag();
 
      template<class T>
      bool operator()(const T& t) const
      {
        return std::isnan(t);
      }
    };
 
    // ******************** Other operators are left as exercise ********************
 
  }
}