xtd::collections::generic::extensions::enumerable< value_t, enumerable_t > Class Template Reference

Inheritance diagram for xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >:

Definition

template<typename value_t, typename enumerable_t>
class xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >

Provides a set of static methods for querying objects that implement ienumerable <type_t>.

Definition

template<typename type_t>
class enumerable : public xtd::static_object;

Header

#include <xtd/linq/generic/extensions/enumerable>

Namespace

xtd::linq

Library

xtd.core

Remarks

You don’t need to inherit from the xtd::collections::generic::extensions::enumerable class when using the xtd::collections::generic::ienumerable interface.

Examples

The following example demonstrates how to use CRTP inheritance with the xtd::collections::generic::extensions::enumerable class.

Examples

The following example is the same example but with xtd::collections::generic::ienumerable interface..

#include <xtd/xtd>
 
struct person {
  string first_name;
  string last_name;
  
  friend auto operator <<(std::ostream& os, const person& p) noexcept -> std::ostream& {return os << p.first_name << " " << p.last_name;}
  friend auto operator <=>(const person&, const person&) noexcept = default;
};
 
struct people : xtd::collections::generic::ienumerable<person> {
  explicit people(iterable auto&& persons) : people_ {persons} {}
  
  auto get_enumerator() const -> enumerator<person> {return people_.get_enumerator();}
  
private:
  list<person> people_;
};
 
auto main() -> int {
  auto people_values = {
    person {.first_name = "john", .last_name = "smith"},
    person {.first_name = "sue", .last_name = "rabon"},
    person {.first_name = "jim", .last_name = "johnson"},
  };
  
  for (auto&& person : people {people_values}.select([](auto&& p) {return person {p.first_name.to_title_case(), p.last_name.to_upper()};}).order())
    println(person);
}
 
// This code produces the following output :
//
// Jim JOHNSON
// John SMITH
// Sue RABON

Public Aliases
using	enumerable_type
	Represents the ienumerable enumerable type.
using	value_type
	Represents the ienumerable value type.
template<typename type_t>
using	ienumerable
	Represents the ienumerable value type.
template<typename type_t>
using	list
	Represents the list value type.

Public Static Methods
auto	aggregate (auto &&funcfunc) const -> value_t
	Applies an accumulator function over a sequence.
auto	aggregate (value_t &&seed, auto &&funcfunc) const -> value_t
	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
auto	aggregate (value_t &&seed, auto &&funcfunc, auto &&result_selector) const
	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.
template<xtd::predicate_callable< value_t > predicate_t>
auto	all (predicate_t &&predicatepredicate) const -> bool
	Determines whether all elements of a sequence satisfy a condition.
auto	any () const noexcept -> bool
	Determines whether a sequence contains any elements.
template<xtd::predicate_callable< value_t > predicate_t>
auto	any (predicate_t &&predicatepredicate) const -> bool
	Determines whether any element of a sequence satisfies a condition.
template<typename element_t>
auto	append (element_t &&element) const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Appends a value to the end of the sequence.
auto	as_enumerable () const noexcept
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
auto	average () const noexcept
	Computes the average of a sequence of value_t values.
template<typename result_t>
auto	cast () const noexcept -> xtd::collections::generic::enumerable_generator< result_t >
	Casts the elements of an xtd::collections::generic::ienumerable to the specified type.
auto	chunk (xtd::usize size) const -> xtd::collections::generic::enumerable_generator< xtd::array< value_t > >
	Splits the elements of a sequence into chunks of size at most size.
template<xtd::iterable second_t>
auto	concat (second_t &&second) const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Concatenates two sequences.
auto	contains (value_t &&value) const noexcept -> bool
	Determines whether a sequence contains a specified element by using the default equality comparer.
auto	contains (value_t &&value, xtd::collections::generic::iequality_comparer< value_t > &&comparer) const noexcept -> bool
	Determines whether a sequence contains a specified element by using a specified equality comparer.
template<xtd::func_callable< bool, value_t, value_t > equater_t>
auto	contains (value_t &&value, equater_t &&equater) const noexcept -> bool
	Determines whether a sequence contains a specified element by using a specified equality comparer.
auto	count () const noexcept -> xtd::usize
	Returns the number of elements in current sequence.
template<xtd::predicate_callable< value_t > predicate_t>
auto	count (predicate_t &&predicatepredicate) const noexcept -> xtd::usize
	Returns a number that represents how many elements in the specified sequence satisfy a condition.
auto	count (value_t &&value) const noexcept -> xtd::usize
	Returns the number of elements with the specified value.
template<typename key_t, xtd::callable< key_t, value_t > key_selector_t>
auto	count_by (key_selector_t &&key_selector) const noexcept
	Returns the count of elements in the current sequence grouped by key.
template<typename key_t, xtd::callable< key_t, value_t > key_selector_t>
auto	count_by (key_selector_t &&key_selector, xtd::collections::generic::iequality_comparer< key_t > &&key_comparer) const noexcept -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >
	Returns the count of elements in the current sequence grouped by key.
template<typename key_t, xtd::callable< key_t, value_t > key_selector_t, xtd::func_callable< bool, key_t, key_t > key_equater_t>
auto	count_by (key_selector_t &&key_selector, key_equater_t &&key_equater) const noexcept -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >
	Returns the count of elements in the current sequence grouped by key.
auto	default_if_empty () const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the current sequence is empty.
auto	default_if_empty (const value_t &default_value) const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the elements of the specified sequence or the specified value in a singleton collection if the current sequence is empty.
auto	distinct () const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns distinct elements from a sequence by using the default equality comparer to compare values.
auto	distinct (xtd::collections::generic::iequality_comparer< value_t > &&comparer) const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.
template<xtd::func_callable< bool, value_t, value_t > equater_t>
auto	distinct (equater_t &&equater) const noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.
auto	first () const -> value_t
	Returns the first element of a sequence.
template<xtd::func_callable< bool, value_t > prediacte_t>
auto	first (prediacte_t &&prediacte) const -> value_t
	Returns the first element in a sequence that satisfies a specified condition.
template<xtd::predicate_callable< value_t > predicate_t>
auto	first_or_default (predicate_t &&predicatepredicate, value_t &&default_value) const noexcept -> value_t
	Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.
template<xtd::predicate_callable< value_t > predicate_t>
auto	first_or_default (predicate_t &&predicatepredicate) const noexcept -> value_t
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
auto	first_or_default (value_t &&default_value) const noexcept -> value_t
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
auto	first_or_default () const noexcept -> value_t
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
auto	last () const -> value_t
	Returns the last element of a sequence.
template<xtd::func_callable< bool, value_t > prediacte_t>
auto	last (prediacte_t &&prediacte) const -> value_t
	Returns the last element in a sequence that satisfies a specified condition.
auto	max () const -> value_t
	Returns the maximum value in a sequence of xtd::numeric values.
template<xtd::callable< value_t, value_t > selector_t> requires xtd::numeric<value_t>
auto	max (selector_t &&selector) const -> value_t
	Returns the maximum value in a sequence of xtd::numeric values.
template<typename result_t, xtd::callable< result_t, value_t > selector_t> requires xtd::numeric<result_t>
auto	max (selector_t &&selector) const -> result_t
	Returns the maximum value in a sequence of xtd::numeric values.
auto	min () const -> value_t
	Returns the minimum value in a sequence of xtd::numeric values.
template<xtd::callable< value_t, value_t > selector_t> requires xtd::numeric<value_t>
auto	min (selector_t &&selector) const -> value_t
	Returns the minimum value in a sequence of xtd::numeric values.
template<typename result_t, xtd::callable< result_t, value_t > selector_t> requires xtd::numeric<result_t>
auto	min (selector_t &&selector) const -> result_t
	Returns the minimum value in a sequence of xtd::numeric values.
auto	order () const -> xtd::collections::generic::enumerable_generator< value_t >
	Sorts the elements of a sequence in ascending order.
auto	order (const xtd::collections::generic::icomparer< value_t > &comparer) const -> xtd::collections::generic::enumerable_generator< value_t >
	Sorts the elements of a sequence in ascending order.
template<xtd::func_callable< bool, value_t, value_t > lesser_t>
auto	order (lesser_t &&lesser) const -> xtd::collections::generic::enumerable_generator< value_t >
	Sorts the elements of a sequence in ascending order.
auto	order_by (const std::function< value_t(const value_t &)> &key_selector) const
	Sorts the elements of a sequence in ascending order according to a key.
template<typename key_t>
auto	order_by_descending (const std::function< key_t(const value_t &)> &key_selector) const
	Sorts the elements of a sequence in descending order according to a key.
auto	order_by_descending (const std::function< value_t(const value_t &)> &key_selector) const
	Sorts the elements of a sequence in descending order according to a key.
template<typename key_t>
auto	order_by (const std::function< key_t(const value_t &)> &key_selector) const
	Sorts the elements of a sequence in ascending order according to a key.
auto	reverse () const -> xtd::collections::generic::enumerable_generator< value_t >
	Inverts the order of the elements in a sequence.
auto	select (auto &&selector) const
	Projects each element of a sequence into a new form.
template<xtd::iterable second_t>
auto	sequence_equal (second_t &&second) const -> bool
	Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.
template<xtd::iterable second_t>
auto	sequence_equal (second_t &&second, const xtd::collections::generic::iequality_comparer< value_t > &equality_comparer) const -> bool
	Determines whether two sequences are equal by comparing their elements by using a specifie the equality comparer.
template<xtd::iterable second_t, xtd::func_callable< bool, value_t, xtd::iterable_value_type< second_t > > equality_comparer_t>
auto	sequence_equal (second_t &&second, equality_comparer_t &&equality_comparer) const -> bool
	Determines whether two sequences are equal by comparing their elements by using a specifie the equality comparer.
auto	shuffle () const -> xtd::collections::generic::enumerable_generator< value_t >
	Shuffles the order of the elements of a sequence.
auto	skip (xtd::usize count) const -> xtd::collections::generic::enumerable_generator< value_t >
	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
auto	skip_while (auto &&predicatepredicate) const -> xtd::collections::generic::enumerable_generator< value_t >
	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
auto	take (xtd::usize count) const -> xtd::collections::generic::enumerable_generator< value_t >
	Returns a specified number of contiguous elements from the start of a sequence.
auto	take (const xtd::range &range) const -> xtd::collections::generic::enumerable_generator< value_t >
	Returns a specified number of contiguous elements from the start of a sequence.
auto	take_while (auto &&predicatepredicate) const -> xtd::collections::generic::enumerable_generator< value_t >
	Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
auto	to_array () const -> xtd::array< value_t >
	Creates a xtd::array <type_t> from an xtd::collections::generic::ienumerable <type_t>.
auto	to_list () const -> xtd::collections::generic::list< value_t >
	Creates a xtd::collections::generic::list <type_t> from an xtd::collections::generic::ienumerable <type_t>.
auto	where (auto &&predicatepredicate) const
	Filters a sequence of values based on a predicate.
template<xtd::iterable second_t>
auto	zip (second_t &&second) const -> xtd::collections::generic::enumerable_generator< std::tuple< value_t, xtd::iterable_value_type< second_t > > >
	Produces a sequence of tuples with elements from the two specified sequences.
template<xtd::iterable second_t>
auto	zip (second_t &&second, auto &&result_selector) const
	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
template<xtd::iterable second_t, xtd::iterable third_t>
auto	zip (second_t &&second, third_t &&third) const -> xtd::collections::generic::enumerable_generator< std::tuple< value_t, xtd::iterable_value_type< second_t >, xtd::iterable_value_type< third_t > > >
	Produces a sequence of tuples with elements from the three specified sequences.
template<xtd::iterable second_t, xtd::iterable third_t>
auto	zip (second_t &&second, third_t &&third, auto &&result_selector) const
	Applies a specified function to the corresponding elements of three sequences, producing a sequence of the results.

Member Typedef Documentation

enumerable_type

template<typename value_t, typename enumerable_t>

using xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::enumerable_type

Represents the ienumerable enumerable type.

value_type

template<typename value_t, typename enumerable_t>

using xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::value_type

Represents the ienumerable value type.

ienumerable

template<typename value_t, typename enumerable_t>

template<typename type_t>

using xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::ienumerable

Represents the ienumerable value type.

list

template<typename value_t, typename enumerable_t>

template<typename type_t>

using xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::list

Represents the list value type.

Member Function Documentation

aggregate() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::aggregate ( auto && func ) const -> value_t

inlinenodiscard

Applies an accumulator function over a sequence.

Parameters

func	An accumulator function to be invoked on each element.

Returns

The final accumulator value.

Examples

The following code example demonstrates how to reverse the order of words in a string by using enumerable::aggregate.

#include <xtd/xtd>
 
auto main() -> int {
  auto sentence = "the quick brown fox jumps over the lazy dog"_s;
  
  // Split the string into individual words.
  auto words = sentence.split(' ');
  
  // Prepend each word to the beginning of the new sentence to reverse the word order.
  auto reversed = words.aggregate(_2 + " " + _1);
 
  console::write_line(reversed.quoted());
}
 
// This code produces the following output :
//
// "dog lazy the over jumps fox brown quick the"

aggregate() [2/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::aggregate ( value_t && seed, auto && func ) const -> value_t

inlinenodiscard

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

Template Parameters

accumulate_t

The type of the accumulator value.

Parameters

seed	The initial accumulator value.
func	An accumulator function to be invoked on each element.

Returns

The final accumulator value.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::aggregate to apply an accumulator function and use a seed value.

#include <xtd/xtd>
 
auto main() -> int {
  auto ints = array {4, 8, 8, 3, 9, 0, 7, 8, 2};
  
  // Count the even numbers in the array, using a seed value of 0.
  auto num_even = ints.aggregate(0, [](auto&& total, auto&& next) {
    return next % 2 == 0 ? total + 1 : total;
  });
 
  console::write_line("The number of even integers is: {}", num_even);
}
 
// This code produces the following output :
//
// The number of even integers is: 6

aggregate() [3/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::aggregate ( value_t && seed, auto && func, auto && result_selector ) const

inlinenodiscard

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

Template Parameters

result_t	The type of the resulting value.
accumulate_t	The type of the accumulator value.

Parameters

seed	The initial accumulator value.
func	An accumulator function to be invoked on each element.
result_Selector	A function to transform the final accumulator value into the result value.

Returns

The transformed final accumulator value.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::aggregate to apply an accumulator function and use a seed value.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "mango", "orange", "passionfruit", "grape"};
  
  // Determine whether any string in the array is longer than "banana".
  auto longest_name = fruits.aggregate("bananas",
     [](auto&& longest, auto&& next) {return next.length() > longest.length() ? next : longest;},
     // Return the final result as an upper case string.
     [](auto&& fruit) {return fruit.to_upper();});
 
  console::write_line("The fruit with the longest name is {}", longest_name);
}
 
// This code produces the following output :
//
// The fruit with the longest name is PASSIONFRUIT

all()

template<typename value_t, typename enumerable_t>

template<xtd::predicate_callable< value_t > predicate_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::all ( predicate_t && predicate ) const -> bool

inlinenodiscard

Determines whether all elements of a sequence satisfy a condition.

Parameters

predicate

A function to test each element for a condition.

Returns

true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::all <value_t> to determine whether all the elements in a sequence satisfy a condition. Variable all_start_with_B is true if all the pet names start with "B" or if the pets array is empty.

#include <xtd/xtd>
 
auto main() -> int {
  struct pet : public object {
    pet() = default;
    pet(const string& name, int age) : name {name}, age {age} {}
    
    string name;
    int age = 0;
  };
  
  // Create an array of pets.
  auto pets = array {
    pet {"Barley", 10},
    pet {"Boots", 4},
    pet {"Whiskers", 6}
  };
  
  // Determine whether all pet names in the array start with 'B'.
  bool all_start_with_b = pets.all([](auto&& pet) {
    return pet.name.starts_with("B");
  });
  
  console::write_line("{} pet names start with 'B'.", all_start_with_b ? "All" : "Not all");
}
 
// This code produces the following output :
//
// Not all pet names start with 'B'.

any() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::any ( ) const -> bool

inlinenodiscardnoexcept

Determines whether a sequence contains any elements.

Returns

true if the source sequence contains any elements; otherwise, false.

Examples

The following code example demonstrates how to use Any to determine whether a sequence contains any elements.

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = list {1, 2};
  auto has_elements = numbers.any();
  
  console::write_line("The list {0} empty.", has_elements ? "is not" : "is");
}
 
// This code produces the following output :
//
// The list is not empty.

any() [2/2]

template<typename value_t, typename enumerable_t>

template<xtd::predicate_callable< value_t > predicate_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::any ( predicate_t && predicate ) const -> bool

inlinenodiscard

Determines whether any element of a sequence satisfies a condition.

Parameters

predicate

A function to test each element for a condition.

Returns

true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::all <value_t> to determine whether all the elements in a sequence satisfy a condition. Variable all_start_with_B is true if all the pet names start with "B" or if the pets array is empty.

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = list {1, 2};
  auto has_elements = numbers.any();
  
  console::write_line("The list {0} empty.", has_elements ? "is not" : "is");
}
 
// This code produces the following output :
//
// The list is not empty.

append()

template<typename value_t, typename enumerable_t>

template<typename element_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::append ( element_t && element ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Appends a value to the end of the sequence.

Parameters

element

The value to append to source.

Returns

A new sequence that ends with element.

Examples

The following code example demonstrates how to use Append to append a value to the end of the sequence.

#include <xtd/xtd>
 
auto main() -> int {
  // Creating a list of numbers
  auto numbers = list {1, 2, 3, 4};
  
  // Trying to append any value of the same type
  auto __ = numbers.append(5);
  
  // It doesn't work because the original list has not been changed
  console::write_line(string::join(", ", numbers));
  
  // It works now because we are using a changed copy of the original list
  console::write_line(string::join(", ", numbers.append(5)));
  
  // If you prefer, you can create a new list explicitly
  auto new_numbers = numbers.append(5).to_list();
  
  // And then write to the console output
  console::write_line(string::join(", ", new_numbers));
}
 
// This code produces the following output :
//
// 1, 2, 3, 4
// 1, 2, 3, 4, 5
// 1, 2, 3, 4, 5

as_enumerable()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::as_enumerable ( ) const

inlinenodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Example

The following code example demonstrates how to use as_enumerable <value_t>(ienumerable <value_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

average()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::average ( ) const

inlinenodiscardnoexcept

Computes the average of a sequence of value_t values.

Returns

The average of this sequence of values.

Exceptions

xtd::invalid_operation_exception

this sequence contains no elements.

cast()

template<typename value_t, typename enumerable_t>

template<typename result_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::cast ( ) const -> xtd::collections::generic::enumerable_generator< result_t >

inlinenodiscardnoexcept

Casts the elements of an xtd::collections::generic::ienumerable to the specified type.

Template Parameters

result_t

The type of the resulting value.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains each element of the source sequence cast to the specified type.

Exceptions

xtd::invalid_cast_exception

An element in the sequence cannot be cast to type result_t.

chunk()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::chunk ( xtd::usize size ) const -> xtd::collections::generic::enumerable_generator< xtd::array< value_t > >

inlinenodiscard

Splits the elements of a sequence into chunks of size at most size.

Parameters

size	The maximum size of each chunk.

Returns

A sequence of chunks of size at most size.

concat()

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::concat ( second_t && second ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Concatenates two sequences.

Parameters

second

The sequence to concatenate to the current sequence.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains the concatenated elements of the two input sequences.

contains() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::contains ( value_t && value ) const -> bool

inlinenodiscardnoexcept

Determines whether a sequence contains a specified element by using the default equality comparer.

Parameters

value

The value to locate in the sequence.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

contains() [2/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::contains ( value_t && value, xtd::collections::generic::iequality_comparer< value_t > && comparer ) const -> bool

inlinenodiscardnoexcept

Determines whether a sequence contains a specified element by using a specified equality comparer.

Parameters

value	The value to locate in the sequence.
comparer	An equality comparer to compare values.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

contains() [3/3]

template<typename value_t, typename enumerable_t>

template<xtd::func_callable< bool, value_t, value_t > equater_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::contains ( value_t && value, equater_t && equater ) const -> bool

inlinenodiscardnoexcept

Determines whether a sequence contains a specified element by using a specified equality comparer.

Parameters

value	The value to locate in the sequence.
comparer	An equality comparer to compare values.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

count() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count ( ) const -> xtd::usize

inlinenodiscardnoexcept

Returns the number of elements in current sequence.

Returns

The number of elements in the input sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count <value_t>(const ienumerable <value_t>&) to count the elements in a sequence.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  auto number_of_fruits = fruits.enumerable::count();
  console::write_line("There are {0} fruits in the collection.", number_of_fruits);
}
 
// This code produces the following output :
//
// There are 6 fruits in the collection.

count() [2/3]

template<typename value_t, typename enumerable_t>

template<xtd::predicate_callable< value_t > predicate_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count ( predicate_t && predicate ) const -> xtd::usize

inlinenodiscardnoexcept

Returns a number that represents how many elements in the specified sequence satisfy a condition.

Parameters

predicate

A function to test each element for a condition.

Returns

A number that represents how many elements in the sequence satisfy the condition in the predicate function.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count <value_t>(const ienumerable <value_t>&, const std::function <bool(const value_t&)>&) to count the elements in a sequence that satisfy a condition.

#include <xtd/xtd>
 
struct pet {
  string name;
  bool vaccinated = false;
};
 
auto main() -> int {
  auto pets = array {
    pet {.name = "Barley", .vaccinated = true},
    pet {.name = "Boots", .vaccinated = false},
    pet {.name = "Whiskers", .vaccinated = false}
  };
  
  auto number_unvaccinated = pets.count(_*member(&pet::vaccinated) == false);
  console::write_line("There are {} unvaccinated animals.", number_unvaccinated);
}
 
// This code produces the following output :
//
// There are 2 unvaccinated animals.

count() [3/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count ( value_t && value ) const -> xtd::usize

inlinenodiscardnoexcept

Returns the number of elements with the specified value.

Parameters

value

The value to search for.

Returns

A number representing the number of elements in the sequence that are equal to the value.

count_by() [1/3]

template<typename value_t, typename enumerable_t>

template<typename key_t, xtd::callable< key_t, value_t > key_selector_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count_by ( key_selector_t && key_selector ) const

inlinenodiscardnoexcept

Returns the count of elements in the current sequence grouped by key.

Template Parameters

key_t

The type of the key returned by key_selector.

Parameters

key_selector

A function to extract the key for each element.

Returns

An enumerable containing the frequencies of each key occurrence in current sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <value_t>(const ienumerable <value_t>&, const std::function <key_t(const value_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>([] (auto&& student) {return student.score;});
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

count_by() [2/3]

template<typename value_t, typename enumerable_t>

template<typename key_t, xtd::callable< key_t, value_t > key_selector_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count_by ( key_selector_t && key_selector, xtd::collections::generic::iequality_comparer< key_t > && key_comparer ) const -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >

inlinenodiscardnoexcept

Returns the count of elements in the current sequence grouped by key.

Template Parameters

key_t

The type of the key returned by key_selector.

Parameters

key_selector	A function to extract the key for each element.
key_comparer	An equality comparer to compare keys.

Returns

An enumerable containing the frequencies of each key occurrence in current sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <value_t>(const ienumerable <value_t>&, const std::function <key_t(const value_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>([] (auto&& student) {return student.score;});
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

count_by() [3/3]

template<typename value_t, typename enumerable_t>

template<typename key_t, xtd::callable< key_t, value_t > key_selector_t, xtd::func_callable< bool, key_t, key_t > key_equater_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::count_by ( key_selector_t && key_selector, key_equater_t && key_equater ) const -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >

inlinenodiscardnoexcept

Returns the count of elements in the current sequence grouped by key.

Template Parameters

key_t

The type of the key returned by key_selector.

Parameters

key_selector	A function to extract the key for each element.
key_comparer	An equality comparer to compare keys.

Returns

An enumerable containing the frequencies of each key occurrence in current sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <value_t>(const ienumerable <value_t>&, const std::function <key_t(const value_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>([] (auto&& student) {return student.score;});
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

default_if_empty() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::default_if_empty ( ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the current sequence is empty.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains default_value if source is empty; otherwise, source.

default_if_empty() [2/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::default_if_empty ( const value_t & default_value ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Returns the elements of the specified sequence or the specified value in a singleton collection if the current sequence is empty.

Parameters

default_value

The value to return if the sequence is empty.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains default_value if source is empty; otherwise, source.

distinct() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::distinct ( ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Returns distinct elements from a sequence by using the default equality comparer to compare values.

Returns

An enumerable distinct elements from the source sequence.

distinct() [2/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::distinct ( xtd::collections::generic::iequality_comparer< value_t > && comparer ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.

Parameters

comparer

An xtd::collections::generic::iequality_comparer <type_t> to compare values.

Returns

An enumerable distinct elements from the source sequence.

distinct() [3/3]

template<typename value_t, typename enumerable_t>

template<xtd::func_callable< bool, value_t, value_t > equater_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::distinct ( equater_t && equater ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscardnoexcept

Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.

Parameters

equater

An equality comparer to compare values.

Returns

An enumerable distinct elements from the source sequence.

first() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first ( ) const -> value_t

inlinenodiscard

Returns the first element of a sequence.

Returns

The first element in the specified sequence.

Exceptions

xtd::invalid_operation_exception

The source sequence is empty.

Remarks

The xtd::linq::enumerable::first <source_t> method throws an exception if source contains no elements. To instead return a default value when the source sequence is empty, use the xtd::linq::enumerable::first_or_default method.

first() [2/2]

template<typename value_t, typename enumerable_t>

template<xtd::func_callable< bool, value_t > prediacte_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first ( prediacte_t && prediacte ) const -> value_t

inlinenodiscard

Returns the first element in a sequence that satisfies a specified condition.

Parameters

predicate

A function to test each element for a condition.

Returns

The first element in the specified sequence.

Exceptions

xtd::invalid_operation_exception

The source sequence is empty.

Remarks

The xtd::linq::enumerable::first <source_t> method throws an exception if source contains no elements. To instead return a default value when the source sequence is empty, use the xtd::linq::enumerable::first_or_default method.

first_or_default() [1/4]

template<typename value_t, typename enumerable_t>

template<xtd::predicate_callable< value_t > predicate_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first_or_default ( predicate_t && predicate, value_t && default_value ) const -> value_t

inlinenodiscardnoexcept

Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.

Parameters

predicate	A function to test each element for a condition.
default_value	The default value to return if the sequence is empty.

Returns

default_value if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [2/4]

template<typename value_t, typename enumerable_t>

template<xtd::predicate_callable< value_t > predicate_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first_or_default ( predicate_t && predicate ) const -> value_t

inlinenodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Parameters

predicate

A function to test each element for a condition.

Returns

default value_t {} if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [3/4]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first_or_default ( value_t && default_value ) const -> value_t

inlinenodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Parameters

default_value

The default value to return if the sequence is empty.

Returns

default_value if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [4/4]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::first_or_default ( ) const -> value_t

inlinenodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Returns

default value_t {} if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

last() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::last ( ) const -> value_t

inlinenodiscard

Returns the last element of a sequence.

Returns

The last element in the specified sequence.

Exceptions

xtd::invalid_operation_exception

The source sequence is empty.

Remarks

The xtd::linq::enumerable::last <source_t> method throws an exception if source contains no elements. To instead return a default value when the source sequence is empty, use the xtd::linq::enumerable::last_or_default method.

last() [2/2]

template<typename value_t, typename enumerable_t>

template<xtd::func_callable< bool, value_t > prediacte_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::last ( prediacte_t && prediacte ) const -> value_t

inlinenodiscard

Returns the last element in a sequence that satisfies a specified condition.

Parameters

predicate

A function to test each element for a condition.

Returns

The last element in the specified sequence.

Exceptions

xtd::invalid_operation_exception

The source sequence is empty.

Remarks

The xtd::linq::enumerable::last <source_t> method throws an exception if source contains no elements. To instead return a default value when the source sequence is empty, use the xtd::linq::enumerable::last_or_default method.

max() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::max ( ) const -> value_t

inlinenodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

max() [2/3]

template<typename value_t, typename enumerable_t>

template<xtd::callable< value_t, value_t > selector_t>
requires xtd::numeric<value_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::max ( selector_t && selector ) const -> value_t

inlinenodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Parameters

selector

A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

max() [3/3]

template<typename value_t, typename enumerable_t>

template<typename result_t, xtd::callable< result_t, value_t > selector_t>
requires xtd::numeric<result_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::max ( selector_t && selector ) const -> result_t

inlinenodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Parameters

selector

A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

min() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::min ( ) const -> value_t

inlinenodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

min() [2/3]

template<typename value_t, typename enumerable_t>

template<xtd::callable< value_t, value_t > selector_t>
requires xtd::numeric<value_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::min ( selector_t && selector ) const -> value_t

inlinenodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Parameters

selector

A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

min() [3/3]

template<typename value_t, typename enumerable_t>

template<typename result_t, xtd::callable< result_t, value_t > selector_t>
requires xtd::numeric<result_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::min ( selector_t && selector ) const -> result_t

inlinenodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Parameters

selector

A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

order() [1/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order ( ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Sorts the elements of a sequence in ascending order.

Returns

An xtd::collections::generic::ienumerable <value_t> whose elements are sorted.

order() [2/3]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order ( const xtd::collections::generic::icomparer< value_t > & comparer ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Sorts the elements of a sequence in ascending order.

Parameters

comparer

An xtd::collections::generic::icomparer <value_t> to compare keys.

Returns

An xtd::collections::generic::ienumerable <value_t> whose elements are sorted.

order() [3/3]

template<typename value_t, typename enumerable_t>

template<xtd::func_callable< bool, value_t, value_t > lesser_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order ( lesser_t && lesser ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Sorts the elements of a sequence in ascending order.

Parameters

lesser

An xtd::collections::generic::icomparer <value_t> to compare keys.

Returns

An xtd::collections::generic::ienumerable <value_t> whose elements are sorted.

order_by() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order_by ( const std::function< value_t(const value_t &)> & key_selector ) const

inlinenodiscard

Sorts the elements of a sequence in ascending order according to a key.

Parameters

key_selector

A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, value_t>(ienumerable <value_t>, std::function<key_t(const value_t&)>) to sort the elements of a sequence.

order_by_descending() [1/2]

template<typename value_t, typename enumerable_t>

template<typename key_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order_by_descending ( const std::function< key_t(const value_t &)> & key_selector ) const

inlinenodiscard

Sorts the elements of a sequence in descending order according to a key.

Parameters

key_selector

A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, value_t>(ienumerable <value_t>, std::function<key_t(const value_t&)>) to sort the elements of a sequence.

order_by_descending() [2/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order_by_descending ( const std::function< value_t(const value_t &)> & key_selector ) const

inlinenodiscard

Sorts the elements of a sequence in descending order according to a key.

Parameters

key_selector

A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, value_t>(ienumerable <value_t>, std::function<key_t(const value_t&)>) to sort the elements of a sequence.

order_by() [2/2]

template<typename value_t, typename enumerable_t>

template<typename key_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::order_by ( const std::function< key_t(const value_t &)> & key_selector ) const

inlinenodiscard

Sorts the elements of a sequence in ascending order according to a key.

Parameters

key_selector

A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, value_t>(ienumerable <value_t>, std::function<key_t(const value_t&)>) to sort the elements of a sequence.

reverse()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::reverse ( ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Inverts the order of the elements in a sequence.

Returns

A sequence whose elements correspond to those of the input sequence in reverse order.

Remarks

This method is implemented by using deferred execution. The immediate return value is an object that stores all the information that is required to perform the action. The query represented by this method is not executed until the object is enumerated either by calling its get_enumerator method directly or by using for range.

select()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::select ( auto && selector ) const

inlinenodiscard

Projects each element of a sequence into a new form.

Parameters

selector

A transform function to apply to each element.

Returns

An xtd::collections::generic::ienumerable <type_t> whose elements are the result of invoking the transform function on each element of source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::select <value_t, result_t>(const ienumerable <value_t>&, const std::function <result_t(const value_t&)>&) to project over a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  const auto& query = fruits.select([](auto&& fruit) {
    static auto index = 0_z;
    return std::make_tuple(index, fruit.substring(0, index++));
  });
 
  for (const auto& [index, str] : query)
    console::write_line("{{ index = {}, str = {} }}", index, str);
}
 
// This code produces the following output :
//
// { index = 0, str =  }
// { index = 1, str = b }
// { index = 2, str = ma }
// { index = 3, str = ora }
// { index = 4, str = pass }
// { index = 5, str = grape }

sequence_equal() [1/3]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::sequence_equal ( second_t && second ) const -> bool

inlinenodiscard

Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

Parameters

first	A sequence of values to compare to second.
second	A sequence of values to compare to first.

Returns

true if the two source sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type; otherwise, false.

sequence_equal() [2/3]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::sequence_equal ( second_t && second, const xtd::collections::generic::iequality_comparer< value_t > & equality_comparer ) const -> bool

inlinenodiscard

Determines whether two sequences are equal by comparing their elements by using a specifie the equality comparer.

Parameters

second	A sequence of values to compare to first.
equality_comparer	An xtd::collections::generic::iequality_comparer <value_t> to use to compare elements.

Returns

true if the two source sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type; otherwise, false.

sequence_equal() [3/3]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t, xtd::func_callable< bool, value_t, xtd::iterable_value_type< second_t > > equality_comparer_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::sequence_equal ( second_t && second, equality_comparer_t && equality_comparer ) const -> bool

inlinenodiscard

Determines whether two sequences are equal by comparing their elements by using a specifie the equality comparer.

Parameters

second	A sequence of values to compare to first.
equality_comparer	An xtd::iterable_value_type<first_t>, xtd::iterable_value_type<second_t>> to use to compare elements.

Returns

true if the two source sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type; otherwise, false.

shuffle()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::shuffle ( ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Shuffles the order of the elements of a sequence.

Returns

A sequence whose elements correspond to those of the input sequence in randomized order.

Warning

Need to include random file #include <xtd/random>.

skip()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::skip ( xtd::usize count ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Bypasses a specified number of elements in a sequence and then returns the remaining elements.

Parameters

count

The number of elements to skip before returning the remaining elements.

Returns

A sequence that contains the elements that occur after the specified index in the input sequence.

skip_while()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::skip_while ( auto && predicate ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

Parameters

predicate

A function to test each element for a condition.

Returns

A sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::skip_while to skip elements of an array as long as a condition is true.

#include <xtd/xtd>
 
auto main() -> int {
  auto grades = array {59, 82, 70, 56, 92, 98, 85};
  
  auto lower_grades = grades.order(_1 > _2).skip_while(_ >= 80).to_array();
  
  println("All grades below 80:");
  for (auto grade : lower_grades)
    println(grade);
}
 
// This code produces the following output :
//
// All grades below 80:
// 70
// 59
// 56

take() [1/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::take ( xtd::usize count ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Returns a specified number of contiguous elements from the start of a sequence.

Parameters

source	A sequence of values to return elements from.
count	The number of elements to return.

Returns

A sequence that contains the specified number of elements from the start of the input sequence.

take() [2/2]

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::take ( const xtd::range & range ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Returns a specified number of contiguous elements from the start of a sequence.

Parameters

source	A sequence of values to return elements from.
range	The range of elements to return.

Returns

A sequence that contains the specified number of elements from the start of the input sequence.

take_while()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::take_while ( auto && predicate ) const -> xtd::collections::generic::enumerable_generator< value_t >

inlinenodiscard

Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements.

Parameters

predicate

A function to test each element for a condition.

Returns

A sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::take_while to return elements from the start of a sequence as long as a condition is true.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  auto query = fruits.take_while([](auto&& fruit) {return string::compare("orange", fruit, true) != 0;}).to_array();
  
  for (auto fruit : query)
    println(fruit);
}
 
// This code produces the following output :
//
// apple
// banana
// mango

to_array()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::to_array ( ) const -> xtd::array< value_t >

nodiscard

Creates a xtd::array <type_t> from an xtd::collections::generic::ienumerable <type_t>.

Returns

A xtd::array <type_t> that contains elements from the input sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::to_array to force immediate query evaluation and return a xtd::array <type_t> that contains the query results.

to_list()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::to_list ( ) const -> xtd::collections::generic::list< value_t >

nodiscard

Creates a xtd::collections::generic::list <type_t> from an xtd::collections::generic::ienumerable <type_t>.

Returns

A xtd::collections::generic::list <type_t> that contains elements from the input sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::to_list to force immediate query evaluation and return a xtd::collections::generic::list <type_t> that contains the query results.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"};
  
  auto lengths = fruits.select(_*method(&string::length)).to_list();
  
  for (auto length : lengths)
    console::write_line(length);
}
 
// This code produces the following output :
//
// 5
// 12
// 6
// 5
// 6
// 9
// 5
// 10

where()

template<typename value_t, typename enumerable_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::where ( auto && predicate ) const

inlinenodiscard

Filters a sequence of values based on a predicate.

Parameters

predicate

A function to test each element for a condition.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains elements from the input sequence that satisfy the condition.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::where <value_t>(const ienumerable <value_t>&, const std::function<bool (const value_t&)>&) to filter a sequence.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple"_s, "passionfruit"_s, "banana"_s, "mango"_s, "orange"_s, "blueberry"_s, "grape"_s, "strawberry"_s};
  
  auto query = fruits.where(_*method(&string::length) < 6);
  
  for (const auto& fruit : query)
    console::write_line(fruit);
}
 
// This code produces the following output :
//
// apple
// mango
// grape

Examples

The following code example demonstrates how to use xtd::linq::enumerable::where <value_t>(const ienumerable <value_t>&, const std::function<bool (const value_t&, xtd::usize)>&) to filter a sequence based on a predicate that involves the index of each element.

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = array {0, 30, 20, 15, 90, 85, 40, 75};
  
  auto query = numbers.where(_1 <= _2 * 10);
  
  for (const auto& number : query)
    console::write_line(number);
}
 
// This code produces the following output :
//
// 0
// 20
// 15
// 40

zip() [1/4]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::zip ( second_t && second ) const -> xtd::collections::generic::enumerable_generator< std::tuple< value_t, xtd::iterable_value_type< second_t > > >

inlinenodiscard

Produces a sequence of tuples with elements from the two specified sequences.

Parameters

second

The second sequence to merge.

Returns

xtd::collections::generic::enumerable_generator<std::tuple<first_value_t, second_value_t> that contains a sequence of tuples with elements taken from the first and second sequences, in that order.

examples

The following example shows hiow to use xtd::linq::enumerable::zip method :

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = array {1, 2, 3, 4, 5};
  auto words = array {"One", "Two", "Three", "Four", "Five"};
  
  auto numbers_and_words = numbers.zip(words);
  
  for (auto&& [number, word] : numbers_and_words)
    println("number = {}, word = {}", number, word);
}
 
// This code produces the following output:
//
// number = 1, word = One
// number = 2, word = Two
// number = 3, word = Three
// number = 4, word = Four
// number = 5, word = Five

zip() [2/4]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::zip ( second_t && second, auto && result_selector ) const

inlinenodiscard

Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

Parameters

second	The second sequence to merge.
result_selector	A function that specifies how to merge the elements from the two sequences.

Returns

xtd::collections::generic::enumerable_generator<std::tuple<first_value_t, second_value_t> that contains a sequence of tuples with elements taken from the first and second sequences, in that order.

examples

The following example shows hiow to use xtd::linq::enumerable::zip method :

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = array {1, 2, 3, 4, 5};
  auto words = array {"One", "Two", "Three", "Four", "Five"};
  
  auto numbers_and_words = numbers.zip(words, _1 + " "_s + _2);
  
  for (auto&& item : numbers_and_words)
    println(item);
}
 
// This code produces the following output:
//
// 1 One
// 2 Two
// 3 Three
// 4 Four
// 5 Five

zip() [3/4]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t, xtd::iterable third_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::zip ( second_t && second, third_t && third ) const -> xtd::collections::generic::enumerable_generator< std::tuple< value_t, xtd::iterable_value_type< second_t >, xtd::iterable_value_type< third_t > > >

inlinenodiscard

Produces a sequence of tuples with elements from the three specified sequences.

Parameters

second	The second sequence to merge.
third	The third sequence to merge.

Returns

xtd::collections::generic::enumerable_generator<std::tuple<first_value_t, second_value_t, third_value_t> that contains a sequence of tuples with elements taken from the first, second and third sequences, in that order.

zip() [4/4]

template<typename value_t, typename enumerable_t>

template<xtd::iterable second_t, xtd::iterable third_t>

auto xtd::collections::generic::extensions::enumerable< value_t, enumerable_t >::zip ( second_t && second, third_t && third, auto && result_selector ) const

inlinenodiscard

Applies a specified function to the corresponding elements of three sequences, producing a sequence of the results.

Parameters

second	The second sequence to merge.
third	The third sequence to merge.
result_selector	A function that specifies how to merge the elements from the three sequences.

Returns

xtd::collections::generic::enumerable_generator<std::tuple<first_value_t, second_value_t, third_value_t> that contains a sequence of tuples with elements taken from the first, second and third sequences, in that order.

---

The documentation for this class was generated from the following file:

• xtd.core/include/xtd/collections/generic/extensions/enumerable.hpp