enumerable_.hpp

Go to the documentation of this file.

#pragma once
#include "../collections/generic/helpers/lesser.hpp"
#include "../collections/generic/helpers/raw_array.hpp"
#include "../collections/generic/comparer.hpp"
#include "../collections/generic/equality_comparer.hpp"
#include "../collections/generic/enumerator.hpp"
#define __XTD_STD_INTERNAL__
#include "../internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#define __XTD_CORE_INTERNAL__
#include "../internal/__array_definition.hpp"
#include "../internal/__key_value_pair_definition.hpp"
#include "../internal/__list_definition.hpp"
#undef  __XTD_CORE_INTERNAL__
#include "../callable.hpp"
#include "../decimal.hpp"
#include "../iterable.hpp"
#include "../iterable_value_type.hpp"
#include "../func_callable.hpp"
#include "../iequatable.hpp"
#include "../int32.hpp"
#include "../int64.hpp"
#include "../numeric.hpp"
#include "../optional.hpp"
#include "../predicate_callable.hpp"
#include "../static.hpp"
#include "../usize.hpp"
#include <algorithm>
#include <bitset>
#include <functional>
#include <queue>
#include <stack>

template<typename type_t>
struct __opaque_xtd_linq_enumerable_collection__;
template<typename type_t, typename param_t>
struct __opaque_xtd_linq_lazy_enumerable__;

namespace xtd {
  namespace collections::generic {
    template<typename type_t>
    class enumerable_generator;
    template<typename type_t>
    class ienumerable;
  }
  
  namespace linq {
  
    class enumerable static_ {
    public:
      
      template<typename type_t>
      using enumerator = typename xtd::collections::generic::enumerator<type_t>;
      
      template<typename type_t>
      using iequality_comparer = typename xtd::collections::generic::iequality_comparer<type_t>;
      
      template<typename type_t>
      using ienumerable = typename xtd::collections::generic::ienumerable<type_t>;
      
      template<typename type_t>
      using list = typename xtd::collections::generic::list<type_t>;
      
      template<typename key_t, typename value_t>
      using key_value_pair = xtd::collections::generic::key_value_pair<key_t, value_t>;
      
      
      template<xtd::iterable source_t, xtd::func_callable<xtd::iterable_value_type<source_t>, xtd::iterable_value_type<source_t>, xtd::iterable_value_type<source_t>> func_t>
      [[nodiscard]] static auto aggregate(const source_t& source, func_t&& func) -> xtd::iterable_value_type<source_t>;
      template<typename accumulate_t, xtd::iterable source_t, xtd::func_callable<accumulate_t, accumulate_t, xtd::iterable_value_type<source_t>> func_t>
      [[nodiscard]] static auto aggregate(const source_t& source, accumulate_t&& seed, func_t&& func) -> accumulate_t;
      template<typename result_t, typename accumulate_t, xtd::iterable source_t, xtd::func_callable<accumulate_t, accumulate_t, xtd::iterable_value_type<source_t>> func_t, xtd::func_callable<result_t, accumulate_t> result_selector_t>
      [[nodiscard]] static auto aggregate(const source_t& source, accumulate_t&& seed, func_t&& func, result_selector_t&& result_selector) -> result_t;
      
      template<xtd::iterable source_t, xtd::predicate_callable<xtd::iterable_value_type<source_t>> predicate_t>
      [[nodiscard]] static auto all(const source_t& source, predicate_t&& predicate) -> bool;
      
      template<xtd::iterable source_t>
      [[nodiscard]] static auto any(const source_t& source) noexcept -> bool;
      template<xtd::iterable source_t, xtd::predicate_callable<xtd::iterable_value_type<source_t>> predicate_t>
      [[nodiscard]] static auto any(const source_t& source, predicate_t&& predicate) -> bool;

      template<xtd::iterable source_t>
      [[nodiscard]] static auto append(source_t&& source, xtd::iterable_value_type<source_t>&& element) noexcept -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>>;
      
      template<xtd::iterable source_t>
      [[nodiscard]] static auto as_enumerable(source_t&& source) noexcept;  // Defined in include/xtd/collections/generic/list.hpp
      template<xtd::iterable source_t>
      [[nodiscard]] static auto as_enumerable(const source_t& source) noexcept -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>>;
      template<xtd::iterable source_t>
      [[nodiscard]] static auto as_enumerable(source_t& source) noexcept -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>>;
      template<typename value_t>
      [[nodiscard]] static auto as_enumerable(std::initializer_list<value_t> source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<std::forward_iterator iterator_t>
      [[nodiscard]] static auto as_enumerable(iterator_t first, iterator_t last) noexcept -> xtd::collections::generic::enumerable_generator<typename std::decay<decltype(*first)>::type>;
      template<std::forward_iterator iterator_t>
      [[nodiscard]] static auto as_enumerable(iterator_t iterator, xtd::usize length) noexcept -> xtd::collections::generic::enumerable_generator<typename std::decay<decltype(*iterator)>::type>;
      template<typename value_t, xtd::usize length>
      [[nodiscard]] static auto as_enumerable(const value_t (&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, xtd::usize length>
      [[nodiscard]] static auto as_enumerable(value_t (&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;

      template<xtd::usize size_>
      [[nodiscard]] static auto as_enumerable(const std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool>; // defined in xtd/collections/bit_array.hpp
      template<xtd::usize size_>
      [[nodiscard]] static auto as_enumerable(std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool>; // defined in xtd/collections/bit_array.hpp
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(const std::queue<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(std::queue<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(const std::priority_queue<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(std::priority_queue<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(const std::stack<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      template<typename value_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(std::stack<value_t, container_t>& source) noexcept -> xtd::collections::generic::enumerable_generator<value_t>;
      
      template<xtd::iterable source_t>
      requires xtd::real_decimal<xtd::iterable_value_type<source_t>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::decimal;
      template<xtd::iterable source_t>
      requires xtd::real_double<xtd::iterable_value_type<source_t>>
      [[nodiscard]] static auto average(const source_t& source) -> double;
      template<xtd::iterable source_t>
      requires xtd::real_single<xtd::iterable_value_type<source_t>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::single;
      template<xtd::iterable source_t>
      requires xtd::signed_integer_32<xtd::iterable_value_type<source_t>>
      [[nodiscard]] static auto average(const source_t& source) -> double;
      template<xtd::iterable source_t>
      requires xtd::signed_integer_64<xtd::iterable_value_type<source_t>>
      [[nodiscard]] static auto average(const source_t& source) -> double;

      template<xtd::iterable source_t>
      requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::decimal>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::optional<xtd::decimal>;
      template<xtd::iterable source_t>
      requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<double>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::optional<double>;
      template<xtd::iterable source_t>
      requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::single>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::optional<xtd::single>;
      template<xtd::iterable source_t>
      requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int32>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::optional<double>;
      template<xtd::iterable source_t>
      requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int64>>
      [[nodiscard]] static auto average(const source_t& source) -> xtd::optional<double>;

      template<typename result_t, xtd::iterable source_t>
      [[nodiscard]] static auto cast(source_t&& source) -> xtd::collections::generic::enumerable_generator<result_t>; // Defined include/xtd/as.hpp
      
      template<xtd::iterable source_t>
      [[nodiscard]] static auto chunk(source_t&& source, xtd::usize size) -> xtd::collections::generic::enumerable_generator<xtd::array<xtd::iterable_value_type<source_t>>>; // Defined in include/xtd/array.hpp
      
      template<xtd::iterable first_t,xtd::iterable second_t>
      [[nodiscard]] static auto concat(first_t&& first, second_t&& second) noexcept  -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<first_t>>;
      
      template<xtd::iterable source_t>
      [[nodiscard]] static auto contains(const source_t& source, const xtd::iterable_value_type<source_t>& value) noexcept -> bool;
      template<xtd::iterable source_t>
      [[nodiscard]] static auto contains(const source_t& source, const xtd::iterable_value_type<source_t>& value, const iequality_comparer<xtd::iterable_value_type<source_t>>& comparer) noexcept -> bool;
      template<xtd::iterable source_t, xtd::func_callable<bool, xtd::iterable_value_type<source_t>, xtd::iterable_value_type<source_t>> equater_t>
      [[nodiscard]] static auto contains(const source_t& source, const xtd::iterable_value_type<source_t>& value, equater_t&& equater) noexcept -> bool;

      template<xtd::iterable source_t>
      [[nodiscard]] static auto count(const source_t& source) noexcept -> xtd::usize;
      template<xtd::iterable source_t, xtd::predicate_callable<xtd::iterable_value_type<source_t>> predicate_t>
      [[nodiscard]] static auto count(const source_t& source, predicate_t&& predicate) noexcept -> xtd::usize;
      template<xtd::iterable source_t>
      [[nodiscard]] static auto count(const source_t& source, xtd::iterable_value_type<source_t>&& value) noexcept -> xtd::usize;
      
      template<typename key_t, xtd::iterable source_t, xtd::callable<key_t, xtd::iterable_value_type<source_t>> key_selector_t>
      [[nodiscard]] static auto count_by(const source_t& source, key_selector_t&& key_selector) noexcept -> xtd::collections::generic::enumerable_generator<xtd::collections::generic::key_value_pair<key_t, xtd::usize>>;
      template<typename key_t, xtd::iterable source_t, xtd::callable<key_t, xtd::iterable_value_type<source_t>> key_selector_t>
      [[nodiscard]] static auto count_by(const source_t& source, key_selector_t&& key_selector, const iequality_comparer<key_t>& key_comparer) noexcept -> xtd::collections::generic::enumerable_generator<xtd::collections::generic::key_value_pair<key_t, xtd::usize>>;
      template<typename key_t, xtd::iterable source_t, xtd::callable<key_t, xtd::iterable_value_type<source_t>> key_selector_t, xtd::callable<bool, key_t, key_t> key_equater_t>
      [[nodiscard]] static auto count_by(const source_t& source, key_selector_t&& key_selector, key_equater_t&& key_equater) noexcept -> xtd::collections::generic::enumerable_generator<xtd::collections::generic::key_value_pair<key_t, xtd::usize>>; // Defined in include/xtd/collections/generic/list.hpp

      template<typename source_t>
      [[nodiscard]] static auto default_if_empty(const ienumerable<source_t>& source) noexcept {
        return default_if_empty(source, source_t {});
      }
      
      template<typename source_t>
      [[nodiscard]] static auto default_if_empty(const ienumerable<source_t>& source, const source_t& default_value) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        if (!any(source)) result.items.push_back(default_value);
        else for (const auto& item : source)
          result.items.push_back(item);
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto distinct(const ienumerable<source_t>& source) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          if (!contains(result, item))
            result.items.push_back(item);
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto distinct(const ienumerable<source_t>& source, const iequality_comparer<source_t>& comparer) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          if (!contains(result, item, comparer))
            result.items.push_back(item);
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto first_or_default(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate, const source_t& default_value) noexcept -> source_t {
        const auto& result = where(source, predicate);
        return any(result) ? *result.begin() : default_value;
      }

      template<typename source_t>
      [[nodiscard]] static auto first_or_default(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) noexcept -> source_t {
        return first_or_default(source, predicate, source_t {});
      }

      template<typename source_t>
      [[nodiscard]] static auto first_or_default(const ienumerable<source_t>& source, const source_t& default_value) noexcept -> source_t {
        return any(source) ? *source.begin() : default_value;
      }

      template<typename source_t>
      [[nodiscard]] static auto first_or_default(const ienumerable<source_t>& source) noexcept -> source_t {
        return first_or_default(source, source_t {});
      }
      
      template<typename source_t>
      [[nodiscard]] static const auto& from(const ienumerable<source_t>& source) noexcept {
        return as_enumerable(source);
      }

      template<typename source_t>
      [[nodiscard]] static auto from(std::initializer_list<source_t> source) noexcept {
        return as_enumerable(source);
      }

      template<typename collection_t>
      [[nodiscard]] static auto from(const collection_t& source) noexcept {
        return as_enumerable(source);
      }

      template<typename input_iterator_t>
      [[nodiscard]] static auto from(input_iterator_t first, input_iterator_t last) noexcept {
        return as_enumerable(first, last);
      }

      template<typename input_iterator_t>
      [[nodiscard]] static auto from(input_iterator_t iterator, xtd::usize length) noexcept {
        return as_enumerable(iterator, iterator + length);
      }

      template<typename source_t, xtd::usize length>
      [[nodiscard]] static auto from(const source_t (&array)[length]) noexcept {
        return as_enumerable(array, array + length);
      }
      
      template<typename source_t, typename container_t>
      [[nodiscard]] static auto from(const std::queue<source_t, container_t>& source) noexcept {
        return as_enumerable(source);
      }
      template<typename source_t, typename container_t>
      [[nodiscard]] static auto from(const std::stack<source_t, container_t>& source) noexcept {
        return as_enumerable(source);
      }
      
      template<typename result_t, typename source_t>
      requires xtd::numeric<result_t>
      [[nodiscard]] static auto max(const ienumerable<source_t>& source, auto&& selector) {
        auto result = std::optional<result_t> {};
        for (const auto& item : source) {
          auto val = selector(item);
          if (!result || val > result) result = val;
        }
        return result.value_or(result_t {});
      }
      
      template<typename source_t>
      requires xtd::numeric<source_t>
      [[nodiscard]] static auto max(const ienumerable<source_t>& source, auto&& selector) {
        auto result = std::optional<source_t> {};
        for (const auto& item : source) {
          auto val = selector(item);
          if (!result || val > result) result = val;
        }
        return result.value_or(source_t {});
      }
      
      template<typename source_t>
      requires xtd::numeric<source_t>
      [[nodiscard]] static auto max(const ienumerable<source_t>& source) {
        auto result = std::optional<source_t> {};
        for (const auto& item : source)
          if (!result || item > result) result = item;
        return result.value_or(source_t {});
      }
 
      template<typename result_t, typename source_t>
      requires xtd::numeric<result_t>
      [[nodiscard]] static auto min(const ienumerable<source_t>& source, auto&& selector) {
        auto result = std::optional<result_t> {};
        for (const auto& item : source) {
          auto val = selector(item);
          if (!result || val < result) result = val;
        }
        return result.value_or(result_t {});
      }
 
      template<typename source_t>
      requires xtd::numeric<source_t>
      [[nodiscard]] static auto min(const ienumerable<source_t>& source, auto&& selector) {
        auto result = std::optional<source_t> {};
        for (const auto& item : source) {
          auto val = selector(item);
          if (!result || val < result) result = val;
        }
        return result.value_or(source_t {});
      }
 
      template<typename source_t>
      requires xtd::numeric<source_t>
      [[nodiscard]] static auto min(const ienumerable<source_t>& source) {
        auto result = std::optional<source_t> {};
        for (const auto& item : source)
          if (!result || item < result) result = item;
        return result.value_or(source_t {});
      }

      template<typename source_t>
      [[nodiscard]] static auto order(const ienumerable<source_t>& source) {
        return order(source, xtd::collections::generic::comparer<source_t>::default_comparer);
      }

      template<typename source_t>
      [[nodiscard]] static auto order(const ienumerable<source_t>& source, const xtd::collections::generic::icomparer<source_t>& comparer) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        std::sort(result.items.begin(), result.items.end(), xtd::collections::generic::helpers::lesser<source_t>(comparer));
        return result;
      }
      
      template<typename key_t, typename source_t>
      [[nodiscard]] static auto order_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) < key_selector(b);});
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto order_by(const ienumerable<source_t>& source, const std::function<source_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) < key_selector(b);});
        return result;
      }
      
      template<typename key_t, typename source_t>
      [[nodiscard]] static auto order_by_descending(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) > key_selector(b);});
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto order_by_descending(const ienumerable<source_t>& source, const std::function<source_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) > key_selector(b);});
        return result;
      }
      
      template<typename type_t>
      [[nodiscard]] static auto range(type_t count) {
        auto step = type_t {};
        return range(type_t {}, count, ++step);
      }

      template<typename type_t>
      [[nodiscard]] static auto range(type_t start, type_t count) {
        auto step = type_t {};
        return range(start, count, ++step);
      }

      template<typename type_t>
      [[nodiscard]] static auto range(type_t start, type_t count, type_t step) {
        if (step == type_t {}) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
        if (count < type_t {}) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        
        auto result = __opaque_xtd_linq_enumerable_collection__<type_t> {};
        for (auto index = type_t {}; index < count; ++index)
          result.items.push_back(start + (index * step));
        return result;
      }
      
      template<typename result_t, xtd::iterable source_t>
      [[nodiscard]] static auto select(source_t&& source, auto&& selector) -> xtd::collections::generic::enumerable_generator<result_t>;
      template<xtd::iterable source_t>
      [[nodiscard]] static auto select(source_t&& source, auto&& selector) -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>>;
      
      template<typename source_t>
      [[nodiscard]] static auto to_array(const ienumerable<source_t>& source); // Defined in include/xtd/array.hpp
      
      template<typename source_t>
      [[nodiscard]] static auto to_list(const ienumerable<source_t>& source); // Defined in include/xtd/collections/generic/list.hpp
      
      template<typename source_t>
      [[nodiscard]] static auto where(const ienumerable<source_t>& source, auto&& predicate) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        auto index = xtd::usize {0};
        for (const auto& item : source)
          if (invoke_predicate_with_optional_index(predicate, item, index++)) result.items.push_back(item);
        return result;
      }

      
    private:      
      template<typename...>
      static inline constexpr bool always_false_v = false;
      
      template<typename predicate_t, typename value_t>
      [[nodiscard]] static constexpr auto invoke_predicate_with_optional_index(predicate_t&& predicate, value_t&& value, xtd::usize index) -> bool;
 
      template<typename result_t, typename selector_t, typename value_t>
      [[nodiscard]] static auto invoke_selector_with_optional_index(selector_t&& selector, value_t&& value, xtd::usize index) -> result_t;
    };
  }
}