functor.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_FUNCTOR_HPP__
#define NEFORCE_CORE_FUNCTIONAL_FUNCTOR_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Arg, typename Result>
struct unary_function {
    using argument_type = Arg;  
    using result_type = Result; 
};

template <typename Arg1, typename Arg2, typename Result>
struct binary_function {
    using first_argument_type = Arg1;  
    using second_argument_type = Arg2; 
    using result_type = Result;        
};
 // LegacyFunctionAdapters


template <typename T = void>
struct plus {
    NEFORCE_NODISCARD constexpr T operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<T>(x + y))) {
        return x + y;
    }
};

template <>
struct plus<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) + static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) + static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) + static_cast<T2&&>(y);
    }
};
 

template <typename T = void>
struct minus {
    NEFORCE_NODISCARD constexpr T operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<T>(x - y))) {
        return x - y;
    }
};

template <>
struct minus<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) - static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) - static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) - static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct multiplies {
    NEFORCE_NODISCARD constexpr T operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<T>(x * y))) {
        return x * y;
    }
};

template <>
struct multiplies<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) * static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) * static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) * static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct divides {
    NEFORCE_NODISCARD constexpr T operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<T>(x / y))) {
        return x / y;
    }
};

template <>
struct divides<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) / static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) / static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) / static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct modulus {
    NEFORCE_NODISCARD constexpr T operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<T>(x % y))) {
        return x % y;
    }
};

template <>
struct modulus<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) % static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) % static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) % static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct negate {
    NEFORCE_NODISCARD constexpr T operator()(const T& x) const noexcept(noexcept(_NEFORCE declcopy<T>(-x))) {
        return -x;
    }
};

template <>
struct negate<void> {
    using is_transparent = void;
 
    template <typename T1>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x) const noexcept(noexcept(-static_cast<T1&&>(x)))
            -> decltype(-static_cast<T1&&>(x)) {
        return -static_cast<T1&&>(x);
    }
};
 // ArithmeticFunctors


template <typename T = void>
struct equal_to {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x == y))) {
        return x == y;
    }
};

template <>
struct equal_to<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) == static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) == static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) == static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct not_equal_to {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x != y))) {
        return x != y;
    }
};

template <>
struct not_equal_to<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) != static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) != static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) != static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct greater {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x > y))) {
        return x > y;
    }
};

template <>
struct greater<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) > static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) > static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) > static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct less {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x < y))) {
        return x < y;
    }
};

template <>
struct less<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) < static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) < static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) < static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct greater_equal {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x >= y))) {
        return x >= y;
    }
};

template <>
struct greater_equal<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) >= static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) >= static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) >= static_cast<T2&&>(y);
    }
};

template <typename T = void>
struct less_equal {
    NEFORCE_NODISCARD constexpr bool operator()(const T& x, const T& y) const
            noexcept(noexcept(_NEFORCE declcopy<bool>(x <= y))) {
        return x <= y;
    }
};

template <>
struct less_equal<void> {
    using is_transparent = void;
 
    template <typename T1, typename T2>
    NEFORCE_NODISCARD constexpr auto operator()(T1&& x, T2&& y) const
            noexcept(noexcept(static_cast<T1&&>(x) <= static_cast<T2&&>(y)))
                    -> decltype(static_cast<T1&&>(x) <= static_cast<T2&&>(y)) {
        return static_cast<T1&&>(x) <= static_cast<T2&&>(y);
    }
};
 // ComparisonFunctors


template <typename T>
struct identity {
    template <typename U = T>
    NEFORCE_NODISCARD constexpr U&& operator()(U&& x) const noexcept {
        return _NEFORCE forward<U>(x);
    }
};
 

template <typename Pair>
struct select1st {
#ifdef NEFORCE_STANDARD_20
    static_assert(is_pair_v<Pair>, "select1st requires pair type.");
#endif // NEFORCE_STANDARD_20
 
    NEFORCE_NODISCARD constexpr const typename Pair::first_type& operator()(const Pair& x) const noexcept {
        return x.first;
    }
};

template <typename Pair>
struct select2nd {
#ifdef NEFORCE_STANDARD_20
    static_assert(is_pair_v<Pair>, "select2nd requires pair type.");
#endif // NEFORCE_STANDARD_20
 
    NEFORCE_NODISCARD constexpr const typename Pair::second_type& operator()(const Pair& x) const noexcept {
        return x.second;
    }
};
 // SelectionFunctors
 // Functor
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_FUNCTOR_HPP__