enumerable.hpp

Go to the documentation of this file.

#pragma once
#include "../../../linq/enumerable_.hpp"
#include "../../../foreach.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      namespace extensions {
        template<typename value_t, typename enumerable_t>
        class enumerable {
        public:
          
          using enumerable_type = enumerable_t;
          using value_type = value_t;
          template<typename type_t>
          using ienumerable = typename xtd::linq::enumerable::ienumerable<type_t>;
          
          template<typename type_t>
          using list = typename xtd::linq::enumerable::list<type_t>;
          
          
          template<xtd::func_callable<value_t, value_t, value_t> func_t>
          [[nodiscard]] auto aggregate(func_t&& func) const -> value_t {
            return xtd::linq::enumerable::aggregate(self(), std::forward<func_t>(func));
          }

          template<typename accumulate_t, xtd::func_callable<accumulate_t, accumulate_t, value_t> func_t>
          [[nodiscard]] auto aggregate(accumulate_t&& seed, func_t&& func) const -> accumulate_t {
            return xtd::linq::enumerable::aggregate(self(), std::forward<accumulate_t>(seed), std::forward<func_t>(func));
          }

          template<typename result_t, typename accumulate_t, xtd::func_callable<accumulate_t, accumulate_t, value_t> func_t, xtd::func_callable<result_t, value_t> result_selector_t>
          [[nodiscard]] auto aggregate(accumulate_t&& seed, func_t&& func, result_selector_t&& result_selector) const -> result_t {
            return xtd::linq::enumerable::aggregate(self(), std::forward<accumulate_t>(seed), std::forward<func_t>(func), std::forward<result_selector_t>(result_selector));
          }
          
          template<xtd::predicate_callable<value_t> predicate_t>
          [[nodiscard]] auto all(predicate_t&& predicate) const -> bool {
            return xtd::linq::enumerable::all(self(), std::forward<predicate_t>(predicate));
          }
          
          [[nodiscard]] auto any() const noexcept -> bool {
            return xtd::linq::enumerable::any(self());
          }

          template<xtd::predicate_callable<value_t> predicate_t>
          [[nodiscard]] auto any(predicate_t&& predicate) const -> bool {
            return xtd::linq::enumerable::any(self(), std::forward<predicate_t>(predicate));
          }
          
          template<typename element_t>
          [[nodiscard]] auto append(element_t&& element) const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::append(self(), std::forward<element_t>(element));
          }
          
          [[nodiscard]] auto as_enumerable() const noexcept {
            return xtd::linq::enumerable::as_enumerable(self());
          }
          
          [[nodiscard]] auto average() const noexcept {
            return xtd::linq::enumerable::average(self());
          }
          
          template<typename result_t>
          [[nodiscard]] auto cast() const noexcept -> xtd::collections::generic::enumerable_generator<result_t> {
            return xtd::linq::enumerable::cast<result_t>(self());
          }
          
          [[nodiscard]] auto chunk(xtd::usize size) const -> xtd::collections::generic::enumerable_generator<xtd::array<value_t>> {
            return xtd::linq::enumerable::chunk(self(), size);
          }
          
          template<xtd::iterable second_t>
          [[nodiscard]] auto concat(second_t&& second) const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::concat(self(), std::forward<second_t>(second));
          }
          
          [[nodiscard]] auto contains(value_t&& value) const noexcept -> bool {
            return xtd::linq::enumerable::contains(self(), std::forward<value_t>(value));
          }

          [[nodiscard]] auto contains(value_t&& value, xtd::collections::generic::iequality_comparer<value_t>&& comparer) const noexcept -> bool {
            return xtd::linq::enumerable::contains(self(), std::forward<value_t>(value), std::forward<xtd::collections::generic::iequality_comparer<value_t>>(comparer));
          }

          template<xtd::func_callable<bool, value_t, value_t> equater_t>
          [[nodiscard]] auto contains(value_t&& value, equater_t&& equater) const noexcept -> bool {
            return xtd::linq::enumerable::contains(self(), std::forward<value_t>(value), std::forward<equater_t>(equater));
          }

          [[nodiscard]] auto count() const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self());
          }

          template<xtd::predicate_callable<value_t> predicate_t>
          [[nodiscard]] auto count(predicate_t&& predicate) const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self(), std::forward<predicate_t>(predicate));
          }

          [[nodiscard]] auto count(value_t&& value) const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self(), std::forward<value_t>(value));
          }
          
          template<typename key_t, xtd::callable<key_t, value_t> key_selector_t>
          [[nodiscard]] auto count_by(key_selector_t&& key_selector) const noexcept {
            return xtd::linq::enumerable::count_by<key_t>(self(), std::forward<key_selector_t>(key_selector));
          }

          template<typename key_t, xtd::callable<key_t, value_t> key_selector_t>
          [[nodiscard]] 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>> {
            return xtd::linq::enumerable::count_by<key_t>(self(), std::forward<key_selector_t>(key_selector), std::forward<xtd::collections::generic::iequality_comparer<key_t>>(key_comparer));
          }

          template<typename key_t, xtd::callable<key_t, value_t> key_selector_t, xtd::callable<bool, key_t, key_t> key_equater_t>
          [[nodiscard]] 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>> {
            return xtd::linq::enumerable::count_by<key_t, value_t>(self(), std::forward<key_selector_t>(key_selector), std::forward<key_equater_t>(key_equater));
          }
          
          [[nodiscard]] auto default_if_empty() const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::default_if_empty(self());
          }

          [[nodiscard]] auto default_if_empty(const value_t& default_value) const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::default_if_empty(self(), default_value);
          }
          
          [[nodiscard]] auto distinct() const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::distinct(self());
          }

          [[nodiscard]] auto distinct(xtd::collections::generic::iequality_comparer<value_t>&& comparer) const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::distinct(self(), std::forward<xtd::collections::generic::iequality_comparer<value_t>>(comparer));
          }

          template<xtd::func_callable<bool, value_t, value_t> equater_t>
          [[nodiscard]] auto distinct(equater_t&& equater) const noexcept -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::distinct(self(), std::forward<equater_t>(equater));
          }

          template<xtd::predicate_callable<value_t> predicate_t>
          [[nodiscard]] auto first_or_default(predicate_t&& predicate, value_t&& default_value) const noexcept -> value_t {
            return xtd::linq::enumerable::first_or_default(self(), std::forward<predicate_t>(predicate), std::forward<value_t>(default_value));
          }

          template<xtd::predicate_callable<value_t> predicate_t>
          [[nodiscard]] auto first_or_default(predicate_t&& predicate) const noexcept -> value_t {
            return xtd::linq::enumerable::first_or_default(self(), std::forward<predicate_t>(predicate));
          }

          [[nodiscard]] auto first_or_default(value_t&& default_value) const noexcept -> value_t {
            return xtd::linq::enumerable::first_or_default(self(), std::forward<value_t>(default_value));
          }

          [[nodiscard]] auto first_or_default() const noexcept -> value_t {
            return xtd::linq::enumerable::first_or_default(self());
          }
          
          [[nodiscard]] auto max() const -> value_t requires xtd::numeric<value_t> {
            return xtd::linq::enumerable::max(self());
          }

          template<xtd::callable<value_t, value_t> selector_t>
          [[nodiscard]] auto max(selector_t&& selector) const -> value_t requires xtd::numeric<value_t> {
            return xtd::linq::enumerable::max(self(), std::forward<selector_t>(selector));
          }

          template<typename result_t, xtd::callable<result_t, value_t> selector_t>
          requires xtd::numeric<result_t>
          [[nodiscard]] auto max(selector_t&& selector) const -> result_t {
            return xtd::linq::enumerable::max<result_t>(self(), std::forward<selector_t>(selector));
          }

          [[nodiscard]] auto min() const -> value_t requires xtd::numeric<value_t> {
            return xtd::linq::enumerable::min(self());
          }

          template<xtd::callable<value_t, value_t> selector_t>
          [[nodiscard]] auto min(selector_t&& selector) const -> value_t requires xtd::numeric<value_t> {
            return xtd::linq::enumerable::min(self(), selector);
          }

          template<typename result_t, xtd::callable<result_t, value_t> selector_t>
          requires xtd::numeric<result_t>
          [[nodiscard]] auto min(selector_t&& selector) const -> result_t {
            return xtd::linq::enumerable::min<result_t, value_t>(self(), selector);
          }

          [[nodiscard]] auto order() const -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::order(self());
          }

          [[nodiscard]] auto order(const xtd::collections::generic::icomparer<value_t>& comparer) const -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::order(self(), comparer);
          }

          template<xtd::func_callable<bool, value_t, value_t> lesser_t>
          [[nodiscard]] auto order(lesser_t&& lesser) const -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::order(self(), lesser);
          }

          [[nodiscard]] auto order_by(const std::function<value_t(const value_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by(self(), key_selector);
          }
          
          template<typename key_t>
          [[nodiscard]] auto order_by_descending(const std::function<key_t(const value_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by_descending<key_t, value_t>(self(), key_selector);
          }
          
          [[nodiscard]] auto order_by_descending(const std::function<value_t(const value_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by_descending(self(), key_selector);
          }
          
          template<typename key_t>
          [[nodiscard]] auto order_by(const std::function<key_t(const value_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by<key_t, value_t>(self(), key_selector);
          }
          
          [[nodiscard]] auto select(auto&& selector) const {
            return xtd::linq::enumerable::select(self(), selector);
          }

          template<typename result_t>
          [[nodiscard]] auto select(auto&& selector) const {
            return xtd::linq::enumerable::select<result_t>(self(), selector);
          }

          [[nodiscard]] auto shuffle() const -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::shuffle(self());
          }

          [[nodiscard]] auto skip(xtd::usize count) -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::skip(self(), count);
          }
          
          [[nodiscard]] auto skip_while(auto&& predicate) -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::skip_while(self(), predicate);
          }
          
          [[nodiscard]] auto take(xtd::usize count) -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::take(self(), count);
          }

          [[nodiscard]] auto take(const xtd::range& range) -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::take(self(), range);
          }
          
          [[nodiscard]] auto take_while(auto&& predicate) -> xtd::collections::generic::enumerable_generator<value_t> {
            return xtd::linq::enumerable::take_while(self(), predicate);
          }
          
          [[nodiscard]] auto to_array() const -> xtd::array<value_t>;
          
          [[nodiscard]] auto to_list() const -> xtd::collections::generic::list<value_t>;
          
          auto where(auto&& predicate) const {
            return xtd::linq::enumerable::where(self(), predicate);
          }

          
        private:
          auto self() const noexcept -> const enumerable_t& {return static_cast<const enumerable_t&>(*this);}
        };
      }
    }
  }
}
 
#define __XTD_CORE_INTERNAL__
#include "../../../internal/__enumerable_collection.hpp"
#undef __XTD_CORE_INTERNAL__
#include "../ienumerable.hpp"