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 enumerable_t, typename source_t>
        class enumerable {
        public:
          
          using enumerable_type = enumerable_t;
          using source_type = source_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>;
          
          
          [[nodiscard]] auto aggregate(const std::function<source_t(const source_t&, const source_t&)>& func) const -> source_t {
            return xtd::linq::enumerable::aggregate(self(), func);
          }

          [[nodiscard]] auto aggregate(const source_t& seed, const std::function<source_t(const source_t&, const source_t&)>& func) const -> source_t {
            return xtd::linq::enumerable::aggregate(self(), seed, func);
          }

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

          [[nodiscard]] auto aggregate(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) const -> source_t {
            return xtd::linq::enumerable::aggregate(self(), seed, func, result_selector);
          }

          template<typename result_t, typename accumulate_t>
          [[nodiscard]] auto aggregate(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) const -> result_t {
            return xtd::linq::enumerable::aggregate(self(), seed, func, result_selector);
          }
          
          [[nodiscard]] auto all(const std::function<bool(const source_t&)>& predicate) const -> bool {
            return xtd::linq::enumerable::all(self(), predicate);
          }
          
          [[nodiscard]] auto any() const noexcept -> bool {
            return xtd::linq::enumerable::any(self());
          }

          [[nodiscard]] auto any(const std::function<bool(const source_t&)>& predicate) const -> bool {
            return xtd::linq::enumerable::any(self(), predicate);
          }
          
          [[nodiscard]] auto append(const source_t& element) const noexcept {
            return xtd::linq::enumerable::append(self(), 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 {
            return xtd::linq::enumerable::cast<result_t>(self());
          }
          
          [[nodiscard]] auto chunk(xtd::usize size) const {
            return xtd::linq::enumerable::chunk(self(), size);
          }
          
          [[nodiscard]] auto concat(const ienumerable<source_t>& second) const noexcept {
            return xtd::linq::enumerable::concat(self(), second);
          }
          
          [[nodiscard]] auto contains(const source_t& value) const noexcept -> bool {
            return xtd::linq::enumerable::contains(self(), value);
          }
          
          [[nodiscard]] auto contains(const source_t& value, const xtd::collections::generic::iequality_comparer<source_t>& comparer) const noexcept -> bool {
            return xtd::linq::enumerable::contains(self(), value, comparer);
          }
          
          [[nodiscard]] auto count() const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self());
          }
          
          [[nodiscard]] auto count(const std::function<bool(const source_t&)>& predicate) const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self(), predicate);
          }
          
          [[nodiscard]] auto count(const source_t& value) const noexcept -> xtd::usize {
            return xtd::linq::enumerable::count(self(), value);
          }
          
          template<typename key_t>
          [[nodiscard]] auto count_by(const std::function<key_t(const source_t&)>& key_selector) const noexcept {
            return xtd::linq::enumerable::count_by<key_t, source_t>(self(), key_selector);
          }
          
          template<typename key_t>
          [[nodiscard]] auto count_by(const std::function<key_t(const source_t&)>& key_selector, const xtd::collections::generic::iequality_comparer<key_t>& key_comparer) const noexcept {
            return xtd::linq::enumerable::count_by<key_t, source_t>(self(), key_selector, key_comparer);
          }
          
          [[nodiscard]] auto default_if_empty() const noexcept {
            return xtd::linq::enumerable::default_if_empty(self());
          }
          
          [[nodiscard]] auto default_if_empty(const source_t& default_value) const noexcept {
            return xtd::linq::enumerable::default_if_empty(self(), default_value);
          }
          
          [[nodiscard]] auto distinct() const noexcept {
            return xtd::linq::enumerable::distinct(self());
          }
          
          [[nodiscard]] auto distinct(const xtd::collections::generic::iequality_comparer<source_t>& comparer) const noexcept {
            return xtd::linq::enumerable::distinct(self(), comparer);
          }
          
          [[nodiscard]] auto first_or_default(const std::function<bool(const source_t&)>& predicate, const source_t& default_value) const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self(), predicate, default_value);
          }

          [[nodiscard]] auto first_or_default(const std::function<bool(const source_t&)>& predicate) const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self(), predicate);
          }
          
          [[nodiscard]] auto first_or_default(const source_t default_value) const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self(), default_value);
          }
          
          [[nodiscard]] auto first_or_default() const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self());
          }
          
          template<typename result_t>
          requires xtd::numeric<result_t>
          [[nodiscard]] auto max(auto&& selector) const {
            return xtd::linq::enumerable::max<result_t, source_t>(self(), selector);
          }
          [[nodiscard]] auto max(auto&& selector) const requires xtd::numeric<source_t> {
            return xtd::linq::enumerable::max(self(), selector);
          }
          [[nodiscard]] auto max() const requires xtd::numeric<source_t> {
            return xtd::linq::enumerable::max(self());
          }
 
          template<typename result_t>
          requires xtd::numeric<result_t>
          [[nodiscard]] auto min(auto&& selector) const {
            return xtd::linq::enumerable::min<result_t, source_t>(self(), selector);
          }
          [[nodiscard]] auto min(auto&& selector) const requires xtd::numeric<source_t> {
            return xtd::linq::enumerable::min(self(), selector);
          }
          [[nodiscard]] auto min() const requires xtd::numeric<source_t> {
            return xtd::linq::enumerable::min(self());
          }

          [[nodiscard]] auto order() const {
            return xtd::linq::enumerable::order(self());
          }

          [[nodiscard]] auto order(const xtd::collections::generic::icomparer<source_t>& comparer) const {
            return xtd::linq::enumerable::order(self(), comparer);
          }
          
          [[nodiscard]] auto order_by(const std::function<source_t(const source_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 source_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by_descending<key_t, source_t>(self(), key_selector);
          }
          
          [[nodiscard]] auto order_by_descending(const std::function<source_t(const source_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 source_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by<key_t, source_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, source_t>(self(), selector);
          }
          
          [[nodiscard]] auto to_array() const noexcept -> xtd::array<source_t>;
          
          [[nodiscard]] auto to_list() const noexcept -> xtd::collections::generic::list<source_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"