futures::all_of_functor

Algorithms / Functions / all_of_functor

^{Defined in header <futures/algorithm/all_of.hpp>}

class all_of_functor;

Functor representing the overloads for the all_of function.

Inherits from unary_invoke_algorithm_functor< Derived >

Public Functions

Member Functions	Description
operator() const	Execute the underlying algorithm. (function template)

Public Functions

function operator()

^{Defined in header <futures/algorithm/traits/unary_invoke_algorithm.hpp>}

(1)

template <
    executor E, 
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    partitioner_for< I, S > P, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(E const & ex, P p, I first, S last, Fun f) const;

(2)

template <
    execution_policy E, 
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    partitioner_for< I, S > P, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(E const &, P p, I first, S last, Fun f) const;

(3)

template <
    executor E, 
    std::ranges::input_range R, 
    partitioner_for< std::ranges::iterator_t< R > > P, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(E const & ex, P p, R && r, Fun f) const;

(4)

template <
    executor E, 
    std::ranges::input_range R, 
    partitioner_for< std::ranges::iterator_t< R > > P, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(E const & ex, P p, R && r, Fun f) const;

(5)

template <
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    partitioner_for< I, S > P, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(P p, I first, S last, Fun f) const;

(6)

template <
    std::ranges::range R, 
    partitioner_for< std::ranges::iterator_t< R > > P, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(P p, R && r, Fun f) const;

(7)

template <
    executor E, 
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(E const & ex, I first, S last, Fun f) const;

(8)

template <
    executor E, 
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(E const & ex, I first, S last, Fun f) const;

(9)

template <
    executor E, 
    std::ranges::input_range R, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(E const & ex, R && r, Fun f) const;

(10)

template <
    executor E, 
    std::ranges::input_range R, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(E const & ex, R && r, Fun f) const;

(11)

template <
    std::input_iterator I, 
    std::sentinel_for< I > S, 
    std::indirectly_unary_invocable< I > Fun>
constexpr
/* see return type below */
operator()(I first, S last, Fun f) const;

(12)

template <
    std::ranges::input_range R, 
    std::indirectly_unary_invocable< std::ranges::iterator_t< R > > Fun>
constexpr
/* see return type below */
operator()(R && r, Fun f) const;

1. Execute the underlying algorithm.
2. Execute the underlying algorithm with an execution policy.
3. Execute the algorithm with a range of iterators.
4. Execute the algorithm with a range of iterators and execution policy.
5. Execute the underlying algorithm with a default executor.
6. Execute the algorithm on a range with a default executor.
7. Execute the underlying algorithm with a default partitioner.
8. Execute the algorithm with execution policy and default partitioner.
9. Execute the algorithm on a range with the default partitioner.
10. Execute the algorithm on a range with policy and default partitioner.
11. Execute the algorithm with default executor and partitioner.
12. Execute algorithm on a range with default executor and partitioner.

Template Parameters

• E - Executor type
• Fun - Function type
• I - Iterator type
• P - Partitioner type
• S - Sentinel type

Parameters

• ex - An executor instance
• f - Function invocable with the return type of the iterator
• first - Iterator to first element in the range
• last - Sentinel iterator to one element past the last
• p - A partitioner instance

Return value

Result of the underlying algorithm

Description

The execution policy is converted into the corresponding executor

Exception Safety

Basic exception guarantee.

---

_{Updated on 2023-01-04}