functors.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2013 Piotr Wygocki
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef PAAL_FUNCTORS_HPP
#define PAAL_FUNCTORS_HPP

#define BOOST_RESULT_OF_USE_DECLTYPE

#include "paal/utils/type_functions.hpp"

#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/iterator_range.hpp>

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <tuple>
#include <utility>

namespace paal {
namespace utils {

// TODO this will not be needed once C++14 auto lambda parameters become available.
struct ignore_param {
    template <class... Args>
        ignore_param(Args&&...) {}
};

struct skip_functor {
    template <typename... Args> void operator()(Args &&... args) const {}
};

template <typename T, T t> struct return_constant_functor {
    template <typename... Args> T operator()(Args &&... args) const {
        return t;
    }
};

template <typename T> struct dynamic_return_constant_functor {
    dynamic_return_constant_functor(T t) : m_t(t) {}

    template <typename... Args> T operator()(Args &&... args) const {
        return m_t;
    }

  private:
    T m_t;
};

template <typename T>
auto make_dynamic_return_constant_functor(T t) {
    return dynamic_return_constant_functor<T>(t);
}

struct identity_functor {
    template <typename Arg> auto operator()(Arg &&arg) const->Arg {
        return std::forward<Arg>(arg);
    }
};

template <typename F, typename G>
auto compose(F f, G g) {
   return std::bind(f, std::bind(g, std::placeholders::_1));
}

template <typename F, typename... Fs>
auto compose(F f, Fs... fs) {
   return compose(f, compose(fs...));
}

namespace detail {
   template <typename T> void get(T t) {}
}

// TODO make it work also with std::tuple, for that use ADL trick for get
// function and branch compile time between boost::tuples::length and
// std::tuple_size.
template <class F>
class tuple_uncurry {
   F m_f;
   public:
      tuple_uncurry(F f) : m_f(f) {}

      template <class Tuple>
      auto operator()(Tuple&& t) const {
         using detail::get;
         return m_f(get<0>(t), get<1>(t));
      }
};

template <class F> auto make_tuple_uncurry(F f) { return tuple_uncurry<F>(f); }

struct always_false : public return_constant_functor<bool, false> {};

struct always_true : public return_constant_functor<bool, true> {};

struct return_zero_functor : public return_constant_functor<int, 0> {};

struct return_one_functor : public return_constant_functor<int, 1> {};

struct assert_functor {
    template <typename... Args> void operator()(Args &&... args) const {
        assert(false);
    }
};

struct remove_reference {
    template <typename T> T operator()(const T &t) const { return t; }
};

template <typename Functor, typename CounterType = int>
class counting_functor_adaptor {
  public:
    counting_functor_adaptor(Functor f, CounterType &cnt)
        : m_cnt(&cnt), m_functor(std::move(f)) {}

    template <typename... Args>
    auto operator()(Args &&... args)
        ->decltype(std::declval<Functor>()(std::forward<Args>(args)...)) {
        ++(*m_cnt);
        return m_functor(std::forward<Args>(args)...);
    }

  private:
    CounterType *m_cnt;
    Functor m_functor;
};

template <typename CounterType = int, typename Functor>
auto make_counting_functor_adaptor(Functor f, CounterType &cnt) {
    return counting_functor_adaptor<Functor, CounterType>(std::move(f), cnt);
}

template <typename Array> class array_to_functor {
  public:
    array_to_functor(const Array &array, int offset = 0)
        : m_array(array), m_offset(offset) {}

    typedef decltype(std::declval<const Array>()[0]) Value;

    Value operator()(int a) const { return m_array.get()[a + m_offset]; }

  private:
    std::reference_wrapper<const Array> m_array;
    int m_offset;
};

template <typename Array>
auto make_array_to_functor(const Array &a, int offset = 0) {
    return array_to_functor<Array>(a, offset);
}

template <typename Functor> struct assignable_functor {
    assignable_functor(Functor const &f) : m_f(f) {}
    assignable_functor() = default;

    assignable_functor &operator=(Functor &f) { m_f = f; }

    template <typename... Args>
    auto operator()(Args &&... args) const->decltype(
        std::declval<Functor>()(std::forward<Args>(args)...)) {
        return m_f.get()(std::forward<Args>(args)...);
    }

  private:
    std::reference_wrapper<const Functor> m_f;
};

template <typename Functor>
auto make_assignable_functor(Functor &f) {
    return assignable_functor<Functor>(f);
}

template <typename Functor> struct lift_iterator_functor {
    lift_iterator_functor(Functor f) : m_f(std::move(f)) {}

    template <typename Iterator>
    auto operator()(Iterator iter) const->decltype(
        std::declval<Functor>()(*iter)) {
        return m_f(*iter);
    }

  private:
    Functor m_f;
};

template <typename Functor>
auto make_lift_iterator_functor(Functor f) {
    return lift_iterator_functor<Functor>(f);
}

//************ The set of comparison functors *******************
// functors are equivalent to corresponding std functors (e.g. std::less) but
// are not templated

struct greater {
    template <class T>
    auto operator()(const T &x, const T &y) const->decltype(x > y) {
        return x > y;
    }
};

struct less {
    template <class T>
    auto operator()(const T &x, const T &y) const->decltype(x < y) {
        return x < y;
    }
};

struct greater_equal {
    template <class T1, class T2>
    auto operator()(const T1 &x, const T2 &y) const->decltype(x >= y) {
        return x >= y;
    }
};

struct less_equal {
    template <class T1, class T2>
    auto operator()(const T1 &x, const T2 &y) const->decltype(x <= y) {
        return x <= y;
    }
};

struct equal_to {
    template <class T>
    auto operator()(const T &x, const T &y) const->decltype(x == y) {
        return x == y;
    }
};

struct equal_to_unspecified {
    template <class T, class U>
    auto operator()(T &&t, U &&u) const->decltype(t == u) {
        return t == u;
    }
};

struct not_equal_to {
    template <class T>
    auto operator()(const T &x, const T &y) const->decltype(x != y) {
        return x != y;
    }
};

template <typename Functor, typename Compare = less>
struct functor_to_comparator {
    functor_to_comparator(Functor f, Compare c = Compare()) : m_f(f), m_c(c) {}

    template <typename T>
    auto operator()(const T &left, const T &right) const->decltype(
        std::declval<Compare>()(std::declval<Functor>()(left),
                                std::declval<Functor>()(right))) {
        return m_c(m_f(left), m_f(right));
    }

  private:
    Functor m_f;
    Compare m_c;
};

template <typename Functor, typename Compare = less>
auto make_functor_to_comparator(Functor functor, Compare compare = Compare()) {
    return functor_to_comparator<Functor, Compare>(std::move(functor),
                                                   std::move(compare));
}

template <typename Functor, typename ScaleType,
          typename ReturnType = ScaleType>
struct scale_functor {

    scale_functor(Functor f, ScaleType s) : m_f(std::move(f)), m_s(s) {}

    template <typename Arg> ReturnType operator()(Arg &&arg) const {
        return m_s * m_f(std::forward<Arg>(arg));
    }

  private:
    Functor m_f;
    ScaleType m_s;
};

template <typename ScaleType, typename ReturnType = ScaleType,
          typename Functor>
auto make_scale_functor(Functor f, ScaleType s) {
    return scale_functor<Functor, ScaleType, ReturnType>(f, s);
}

//****************************** This is a set of functors representing standard
// arithmetic
// operations that is +, -, etc. These are equivalent to standard std:: structs
// but are not templated
struct plus {
    template <typename T1, typename T2>
    auto operator()(T1&& left, T2&& right) const
    -> decltype(std::forward<T1>(left) + std::forward<T2>(right)) {
        return std::forward<T1>(left) + std::forward<T2>(right);
    }
    // TODO change other operations (minus, max, less, etc..) like this one:
    // with two different types and perfect forwarding
};

struct minus {
    template <typename T>
    auto operator()(const T &left,
                    const T &right) const->decltype(left - right) {
        return left - right;
    }
};

struct max {
    template <typename T>
    auto operator()(const T &left,
                    const T &right) const->decltype(std::max(left, right)) {
        return std::max(left, right);
    }
};

struct min {
    template <typename T>
    auto operator()(const T &left,
                    const T &right) const->decltype(std::min(left, right)) {
        return std::min(left, right);
    }
};

//****************************** This is a set of functors representing standard
// boolean operations
// that is !, &&, ||. These are equivalent to standard std:: structs but are not
// templated
//(only operator() is templated)

struct Not {
    template <typename T> auto operator()(const T &b) const->decltype(!b) {
        return !b;
    }
};

struct Or {
    template <typename T>
    auto operator()(const T &left,
                    const T &right) const->decltype(left || right) {
        return left || right;
    }
};

struct And {
    template <typename T>
    auto operator()(const T &left,
                    const T &right) const->decltype(left &&right) {
        return left && right;
    }
};

template <typename FunctorLeft, typename FunctorRight, typename Operator>
struct lift_binary_operator_functor {
    lift_binary_operator_functor(FunctorLeft left = FunctorLeft(),
                                 FunctorRight right = FunctorRight(),
                                 Operator op = Operator())
        : m_left(std::move(left)), m_right(std::move(right)),
          m_operator(std::move(op)) {}

    template <typename... Args>
    auto operator()(Args &&... args) const->decltype(std::declval<Operator>()(
        std::declval<FunctorLeft>()(std::forward<Args>(args)...),
        std::declval<FunctorRight>()(std::forward<Args>(args)...))) {
        return m_operator(m_left(std::forward<Args>(args)...),
                          m_right(std::forward<Args>(args)...));
    }

  private:
    FunctorLeft m_left;
    FunctorRight m_right;
    Operator m_operator;
};

template <typename FunctorLeft, typename FunctorRight, typename Operator>
auto make_lift_binary_operator_functor(FunctorLeft left, FunctorRight right,
                                       Operator op) {
    return lift_binary_operator_functor<FunctorLeft, FunctorRight, Operator>(
        std::move(left), std::move(right), std::move(op));
}

//******************** this is set of functors
// allowing to compose functors using
// standard logical operators

template <typename Functor> struct not_functor {
    not_functor(Functor functor = Functor()) : m_functor(functor) {}

    template <typename... Args>
    auto operator()(Args &&... args) const->decltype(
        std::declval<Functor>()(std::forward<Args>(args)...)) {
        return !m_functor(std::forward<Args>(args)...);
    }

  private:
    Functor m_functor;
};

template <typename Functor>
auto make_not_functor(Functor functor) {
    return not_functor<Functor>(std::move(functor));
}

template <typename FunctorLeft, typename FunctorRight>
struct or_functor
    : public lift_binary_operator_functor<FunctorLeft, FunctorRight, Or> {
    typedef lift_binary_operator_functor<FunctorLeft, FunctorRight, Or> base;

    or_functor(FunctorLeft left = FunctorLeft(),
               FunctorRight right = FunctorRight())
        : base(std::move(left), std::move(right)) {}
};

template <typename FunctorLeft, typename FunctorRight>
auto make_or_functor(FunctorLeft left,
                     FunctorRight right) {
    return or_functor<FunctorLeft, FunctorRight>(std::move(left),
                                                 std::move(right));
}

template <typename FunctorLeft, typename FunctorRight>
struct and_functor
    : public lift_binary_operator_functor<FunctorLeft, FunctorRight, And> {
    typedef lift_binary_operator_functor<FunctorLeft, FunctorRight, And> base;

    and_functor(FunctorLeft left = FunctorLeft(),
                FunctorRight right = FunctorRight())
        : base(std::move(left), std::move(right)) {}
};

template <typename FunctorLeft, typename FunctorRight>
auto make_and_functor(FunctorLeft left, FunctorRight right) {
    return and_functor<FunctorLeft, FunctorRight>(std::move(left),
                                                  std::move(right));
}

template <typename FunctorLeft, typename FunctorRight>
struct xor_functor : public lift_binary_operator_functor<
    FunctorLeft, FunctorRight, not_equal_to> {
    typedef lift_binary_operator_functor<FunctorLeft, FunctorRight,
                                         not_equal_to> base;

    xor_functor(FunctorLeft left = FunctorLeft(),
                FunctorRight right = FunctorRight())
        : base(std::move(left), std::move(right)) {}
};

template <typename FunctorLeft, typename FunctorRight>
auto make_xor_functor(FunctorLeft left, FunctorRight right) {
    return xor_functor<FunctorLeft, FunctorRight>(std::move(left),
                                                  std::move(right));
}

template <std::size_t I>
struct tuple_get {
    template <typename Tuple>
    //TODO change to decltype(auto), when it starts working
    auto operator()(Tuple &&tuple) const ->
            decltype(std::get<I>(std::forward<Tuple>(tuple))) {
        return std::get<I>(std::forward<Tuple>(tuple));
    }
};

} 
} 
#endif // PAAL_FUNCTORS_HPP