enumerable.hpp

Go to the documentation of this file.

#pragma once
#include "../collections/generic/helpers/allocator.hpp"
#include "../collections/generic/helpers/lesser.hpp"
#include "../collections/generic/helpers/raw_array.hpp"
//#include "../collections/generic/iequality_comparer.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 "../decimal.hpp"
#include "../iequatable.hpp"
#include "../int32.hpp"
#include "../int64.hpp"
#include "../numeric.hpp"
#include "../optional.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 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<typename source_t>
      [[nodiscard]] static auto aggregate(const ienumerable<source_t>& source, const std::function<source_t(const source_t&, const source_t&)>& func) -> source_t {
        auto nb = 0;
        auto aggregated = source_t {};
        for (const auto& item : source)
          if (nb++ == 0) aggregated = item;
          else aggregated = func(aggregated, item);
        return aggregated;
      }

      template<typename source_t>
      [[nodiscard]] static auto aggregate(const ienumerable<source_t>& source, const source_t& seed, const std::function<source_t(const source_t&, const source_t&)>& func) -> source_t {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return aggregated;
      }

      template<typename accumulate_t, typename source_t>
      [[nodiscard]] static auto aggregate(const ienumerable<source_t>& source, const accumulate_t& seed, const std::function<accumulate_t(const accumulate_t&, const source_t&)>& func) -> accumulate_t {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return aggregated;
      }

      template<typename source_t>
      [[nodiscard]] static auto aggregate(const ienumerable<source_t>& source, const source_t& seed, const std::function<source_t(const source_t&, const source_t&)>& func, const std::function<source_t(const source_t&)>& result_selector) -> source_t {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return result_selector(aggregated);
      }

      template<typename result_t, typename accumulate_t, typename source_t>
      [[nodiscard]] static auto aggregate(const ienumerable<source_t>& source, const accumulate_t& seed, const std::function<accumulate_t(const accumulate_t&, const source_t&)>& func, const std::function<result_t(const accumulate_t&)>& result_selector) -> result_t {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return result_selector(aggregated);
      }
      
      template<typename source_t>
      [[nodiscard]] static auto all(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) -> bool {
        for (const auto& item : source)
          if (!predicate(item)) return false;
        return true;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto any(const ienumerable<source_t>& source) noexcept -> bool {
        return source.begin() != source.end();
      }

      template<typename source_t>
      [[nodiscard]] static auto any(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) -> bool {
        for (const auto& item : source)
          if (predicate(item)) return true;
        return false;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto append(const ienumerable<source_t>& source, const source_t& element) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        result.items.push_back(element);
        return result;
      }
      
      /*
       template<typename source_t>
       [[nodiscard]] static auto append(const ienumerable<source_t>& source, const source_t& element) noexcept {
       using param_type = std::tuple<source_t, enumerator<source_t>, source_t, bool>;
       auto result = __opaque_xtd_linq_lazy_enumerable__<source_t, param_type> {};
       
       result = __opaque_xtd_linq_lazy_enumerable__<source_t, param_type> {
       std::make_tuple(source_t {}, source.get_enumerator(), element, false),
       [](param_type& params) {
       auto& result = std::get<0>(params);
       auto& source_enumerator = std::get<1>(params);
       const auto& element = std::get<2>(params);
       auto& appended = std::get<3>(params);
       
       if (source_enumerator.move_next()) {
       result = source_enumerator.current();
       return true;
       }
       
       if (!appended) {
       appended = true;
       result = element;
       return true;
       }
       
       return false;
       },
       [](param_type& params) {
       auto& result = std::get<0>(params);
       auto& source_enumerator = std::get<1>(params);
       auto& appended = std::get<3>(params);
       
       result = source_t {};
       source_enumerator.reset();
       appended = false;
       }
       };
       
       return result;
       }*/
      
      template<typename source_t>
      [[nodiscard]] static const auto& as_enumerable(const ienumerable<source_t>& source) noexcept {
        return source;
      }

      template<typename source_t>
      [[nodiscard]] static auto as_enumerable(std::initializer_list<source_t> source) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        return result;
      }

      template<typename collection_t>
      [[nodiscard]] static auto as_enumerable(collection_t&& source) noexcept {
#if defined(__xtd__cpp_lib_ranges)
        using source_t = std::ranges::range_value_t<collection_t>;
#else
        using source_t = typename collection_t::value_type;
#endif
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (auto&& item : source)
          result.items.push_back(item);
        return result;
      }

      template<typename input_iterator_t>
      [[nodiscard]] static auto as_enumerable(input_iterator_t first, input_iterator_t last) noexcept {
        using source_t = typename std::decay<decltype(*first)>::type;
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (auto iterator = first; iterator != last; ++iterator)
          result.items.push_back(*iterator);
        return result;
      }

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

      template<typename source_t, xtd::usize length>
      [[nodiscard]] static auto as_enumerable(const source_t (&array)[length]) noexcept {
        return as_enumerable(array, array + length);
      }
      
      template<xtd::usize size_>
      [[nodiscard]] static auto as_enumerable(std::bitset<size_> source); // defined in xtd/collections/bit_array.hpp
      template<typename source_t, typename container_t>
      static auto as_enumerable(std::queue<source_t, container_t> source) noexcept {
        struct accessor : public std::queue<source_t> {static auto get() {return &accessor::c;}};
        const auto& underlying_items = source.*accessor::get();
        return as_enumerable(underlying_items.begin(), underlying_items.end());
      }
      template<typename source_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(std::priority_queue<source_t, container_t> source) noexcept {
        struct accessor : public std::priority_queue<source_t> {static auto get() {return &accessor::c;}};
        const auto& underlying_items = source.*accessor::get();
        return as_enumerable(underlying_items.begin(), underlying_items.end());
      }
      template<typename source_t, typename container_t>
      [[nodiscard]] static auto as_enumerable(std::stack<source_t, container_t> source) noexcept {
        struct accessor : public std::stack<source_t> {static auto get() {return &accessor::c;}};
        const auto& underlying_items = source.*accessor::get();
        return as_enumerable(underlying_items.begin(), underlying_items.end());
      }
      
      [[nodiscard]] static auto average(const ienumerable<xtd::decimal>& source) -> xtd::decimal;
      [[nodiscard]] static auto average(const ienumerable<double>& source) -> double;
      [[nodiscard]] static auto average(const ienumerable<float>& source) -> float;
      [[nodiscard]] static auto average(const ienumerable<xtd::int32>& source) -> double;
      [[nodiscard]] static auto average(const ienumerable<xtd::int64>& source) -> double;
      
      [[nodiscard]] static auto average(const ienumerable<xtd::optional<xtd::decimal >>& source) noexcept -> xtd::optional<xtd::decimal>;
      [[nodiscard]] static auto average(const ienumerable<xtd::optional<double >>& source) noexcept -> xtd::optional<double>;
      [[nodiscard]] static auto average(const ienumerable<xtd::optional<float >>& source) noexcept -> xtd::optional<float>;
      [[nodiscard]] static auto average(const ienumerable<xtd::optional<xtd::int32 >>& source) noexcept -> xtd::optional<double>;
      [[nodiscard]] static auto average(const ienumerable<xtd::optional<xtd::int64 >>& source) noexcept -> xtd::optional<double>;
      
      template<typename result_t, typename source_t>
      [[nodiscard]] static auto cast(const ienumerable<source_t>& source) noexcept; // Defined include/xtd/as.hpp
      
      template<typename source_t>
      [[nodiscard]] static auto chunk(const ienumerable<source_t>& source, xtd::usize size); // Defined in include/xtd/array.hpp
      
      template<typename source_t>
      [[nodiscard]] static auto concat(const ienumerable<source_t>& first, const ienumerable<source_t>& second) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : first)
          result.items.push_back(item);
        for (const auto& item : second)
          result.items.push_back(item);
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto contains(const ienumerable<source_t>& source, const source_t& value) noexcept -> bool {
        for (const auto& item : source)
          if (item == value) return true;
        return false;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto contains(const ienumerable<source_t>& source, const source_t& value, const xtd::collections::generic::iequality_comparer<source_t>& comparer) noexcept -> bool {
        for (const auto& item : source)
          if (comparer.equals(item, value)) return true;
        return false;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto count(const ienumerable<source_t>& source) noexcept -> xtd::usize {
        auto count = xtd::usize {0};
        auto enumerator = source.get_enumerator();
        while (enumerator.move_next()) ++count;
        return count;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto count(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) noexcept -> xtd::usize {
        return where<source_t>(source, predicate).count();
      }
      
      template<typename source_t>
      [[nodiscard]] static auto count(const ienumerable<source_t>& source, const source_t& value) noexcept -> xtd::usize {
        return count<source_t>(source, [value](const source_t& item) -> bool {return item == value;});
      }
      
      template<typename key_t, typename source_t>
      [[nodiscard]] static auto count_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) noexcept {
        return count_by(source, key_selector, xtd::collections::generic::equality_comparer<key_t>::default_equality_comparer());
      }
      
      template<typename key_t, typename source_t>
      [[nodiscard]] static auto count_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector, const iequality_comparer<key_t>& key_comparer) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<key_value_pair<key_t, xtd::usize>> {};
        auto keys = list<key_t> {};
        auto enumerator = source.get_enumerator();
        while (enumerator.move_next()) {
          auto key = key_selector(enumerator.current());
          auto index = xtd::usize {0};
          for (; index < keys.count(); ++index)
            if (key_comparer.equals(keys[index], key)) break;
          if (index < keys.count()) result.items[index] = {key, result.items[index].value() + 1};
          else {
            keys.add(key);
            result.items.push_back({key, 1});
          }
        }
        return result;
      }
      
      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 xtd::collections::generic::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(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(std::queue<source_t, container_t> source) noexcept {
        return as_enumerable(source);
      }
      template<typename source_t, typename container_t>
      [[nodiscard]] static auto from(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, typename source_t>
      [[nodiscard]] static auto select(const ienumerable<source_t>& source, auto&& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<result_t> {};
        auto index = xtd::usize {0};
        for (const auto& item : source)
          result.items.push_back(invoke_selector_wtih_optional_index(selector, item, index++));
        return result;
      }

      template<typename source_t>
      [[nodiscard]] static auto select(const ienumerable<source_t>& source, auto&& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        auto index = xtd::usize {0};
        for (const auto& item : source)
          result.items.push_back(invoke_selector_wtih_optional_index(selector, item, index++));
        return result;
      }
      
      template<typename source_t>
      [[nodiscard]] static auto to_array(const ienumerable<source_t>& source) noexcept; // Defined in include/xtd/array.hpp
      
      template<typename source_t>
      [[nodiscard]] static auto to_list(const ienumerable<source_t>& source) noexcept; // 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_wtih_optional_index(predicate, item, index++)) result.items.push_back(item);
        return result;
      }

      
    private:
      template <typename predicate_t, typename source_t>
      static constexpr bool invoke_predicate_wtih_optional_index(predicate_t&& predicate, source_t&& value, xtd::usize index) {
        if constexpr (requires { predicate(value, index); }) return predicate(value, index);
        else return predicate(value);
      }
      
      template <typename selector_t, typename source_t>
      static auto invoke_selector_wtih_optional_index(selector_t&& selector, source_t&& value, xtd::usize index) {
        if constexpr (requires { selector(value, index); }) return selector(value, index);
        else return selector(value);
      }
    };
  }
}
 
#include "../collections/generic/extensions/enumerable.hpp"
#include "from.hpp"