functional.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    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 ADOBE_FUNCTIONAL_HPP
#define ADOBE_FUNCTIONAL_HPP
 
#include <adobe/config.hpp>
 
#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <boost/compressed_pair.hpp>
 
#include <adobe/functional/is_member.hpp>
#include <adobe/functional/operator.hpp>
#include <adobe/utility/pair.hpp>
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/

 
/*
    REVISIT (sparent) : Documentation for delete_ptr moved to adobe/functional.hpp because doxygen
    1.4.3 cannot handle the template specializations.
*/









 

 
template <typename F, // models UnaryFunction
          typename G> // models UnaryFunction -> argument_type(F)
struct unary_compose {
    unary_compose() {}
    unary_compose(F f, G g) : data_m(f, g) {}
 
    template <typename U> // U models Regular
    auto operator()(const U& x) const {
        return data_m.first()(data_m.second()(x));
    }
 
    template <typename U> // U models Regular
    auto operator()(U& x) const {
        return data_m.first()(data_m.second()(x));
    }
 
private:
    boost::compressed_pair<F, G> data_m;
};
 
/**************************************************************************************************/
 
template <typename F, // models UnaryFunction
          typename G>
// models UnaryFunction -> argument_type(F)
unary_compose<F, G> compose(F f, G g) {
    return unary_compose<F, G>(f, g);
}
 
/**************************************************************************************************/
 
template <typename F,     // models BinaryFunction
          typename G,     // models UnaryFunction -> argument_type(F, 0);
          typename H = G> // models UnaryFunction -> argument_type(F, 1);
struct binary_compose {
    typedef typename F::result_type result_type;
 
    template <typename T, typename U> // models Regular
    result_type operator()(const T& x, const U& y) const {
        return f(g(x), h(y));
    }
 
    template <typename T, typename U> // models Regular
    result_type operator()(T& x, U& y) const {
        return f(g(x), h(y));
    }
 
    F f;
    G g;
    H h;
};
 
/**************************************************************************************************/

template <std::size_t I, class T>
using element = std::tuple_element<I, T>;
 
/**************************************************************************************************/
 
template <std::size_t I, class T = void>
struct get_element {
    auto operator()(T& x) const -> std::tuple_element_t<I, T>& {
        return std::get<I>(x);
    }
 
    auto operator()(const T& x) const -> const std::tuple_element_t<I, T>& {
        return std::get<I>(x);
    }
};
 
template <std::size_t I>
struct get_element<I, void> {
    template <class T>
    auto operator()(T& x) const -> std::tuple_element_t<I, T>& {
        return std::get<I>(x);
    }
 
    template <class T>
    auto operator()(const T& x) const -> const std::tuple_element_t<I, T>& {
        return std::get<I>(x);
    }
};
 
/**************************************************************************************************/
 
template <typename T>
struct always_true {
    bool operator()(const T&) const { return true; }
};
 
/**************************************************************************************************/
 
template <class Result>
struct generator_t {
    typedef Result result_type;
};
 
/**************************************************************************************************/
 
 
template <typename T>
struct sequence_t
#if !defined(ADOBE_NO_DOCUMENTATION)
    : generator_t<T>
#endif
{
    explicit sequence_t(const T& x) : data_m(x) {}
    T operator()() { return data_m++; }
 
private:
    T data_m;
};
 
/**************************************************************************************************/
 
template <class T, typename R, class Compare>
struct compare_members_t {
    compare_members_t(R T::* member, Compare compare) : compare_m(compare), member_m(member) {}
 
    bool operator()(const T& x, const T& y) const { return compare_m(x.*member_m, y.*member_m); }
 
    bool operator()(const T& x, const R& y) const { return compare_m(x.*member_m, y); }
 
    bool operator()(const R& x, const T& y) const { return compare_m(x, y.*member_m); }
 
private:
    /*
        REVISIT (sparent) : This could probably use an empty member optimization.
    */
 
    Compare compare_m;
    R T::* member_m;
};
 
template <class T, typename R>
compare_members_t<T, R, std::less<R>> compare_members(R T::* member) {
    return compare_members_t<T, R, std::less<R>>(member, std::less<R>());
}
 
template <class T, typename R, class Compare>
compare_members_t<T, R, Compare> compare_members(R T::* member, Compare compare) {
    return compare_members_t<T, R, Compare>(member, compare);
}
 
/**************************************************************************************************/
 
template <class T, typename R>
struct mem_data_t {
    mem_data_t() {}
 
    explicit mem_data_t(R T::* member) : member_m(member) {}
 
    R& operator()(T& x) const { return x.*member_m; }
 
    const R& operator()(const T& x) const { return x.*member_m; }
 
private:
    R T::* member_m;
};
 
template <class T, typename R>
struct mem_data_t<const T, R> {
    explicit mem_data_t(R T::* member) : member_m(member) {}
 
    const R& operator()(const T& x) const { return x.*member_m; }
 
private:
    R T::* member_m;
};
 
template <class T, typename R>
mem_data_t<T, R> mem_data(R T::* member) {
    return mem_data_t<T, R>(member);
}
 
/**************************************************************************************************/
 
template <typename O> // O models StrictWeakOrdering
struct equivalent {
public:
    explicit equivalent(const O& x) : o_m(x) {}
 
    bool operator()(const typename O::first_argument_type& x,
                    const typename O::second_argument_type& y) const {
        return !o_m(x, y) && !o_m(y, x);
    }
 
private:
    O o_m;
};
 
/**************************************************************************************************/

template <class F> // F models a BinaryFunction
struct transpose {
    F function;
 
    transpose() = default;
    explicit transpose(F&& f) noexcept : function(std::move(f)) {}
    explicit transpose(const F& f) : function(f) {}
 
    transpose(const transpose& x) = default;
    transpose(transpose&& x) noexcept = default;
 
    transpose& operator=(const transpose& x) = default;
    transpose& operator=(transpose&& x) noexcept = default;
 
    template <class T1, class T2>
    auto operator()(T1&& x, T2&& y) const& noexcept(std::is_nothrow_invocable_v<const F&, T2, T1>) {
        return function(std::forward<T2>(y), std::forward<T1>(x));
    }
 
    template <class T1, class T2>
    auto operator()(T1&& x, T2&& y) & noexcept(std::is_nothrow_invocable_v<F&, T2, T1>) {
        return function(std::forward<T2>(y), std::forward<T1>(x));
    }
 
    template <class T1, class T2>
    auto operator()(T1&& x, T2&& y) && noexcept(std::is_nothrow_invocable_v<F&&, T2, T1>) {
        return std::move(function)(std::forward<T2>(y), std::forward<T1>(x));
    }
};
 
template <class F> // F models a BinaryFunction
using transposer [[deprecated("Use `adobe::transpose` instead.")]] = transpose<F>;
 
 
template <typename F> // F models BinaryFunction
inline auto f_transpose [[deprecated("Use `adobe::transpose` instead.")]] (F f) -> transpose<F> {
    return transpose<F>(f);
}

 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/