enumerable.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace collections {
    namespace generic {
      namespace extensions {
        template <class enumerable_t, class source_t>
        class enumerable {
        public:
          
          using enumerable_type = enumerable_t;
          using source_type = source_t;
          template <class type_t>
          using ienumerable = typename xtd::linq::enumerable::ienumerable<type_t>;
          
          template <class type_t>
          using list = typename xtd::linq::enumerable::list<type_t>;
          
          
          auto aggregate(const std::function<source_t(const source_t&, const source_t&)>& func) const -> source_t {
            return xtd::linq::enumerable::aggregate(self(), func);
          }

          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<class accumulate_t>
          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);
          }

          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<class result_t, class accumulate_t>
          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);
          }
          
          auto all(const std::function<bool(const source_t&)>& predicate) const -> bool {
            return xtd::linq::enumerable::all(self(), predicate);
          }
          
          auto any() const noexcept -> bool {
            return xtd::linq::enumerable::any(self());
          }

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

          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);
          }
          
          auto first_or_default(const source_t default_value) const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self(), default_value);
          }
          
          auto first_or_default() const noexcept -> source_t {
            return xtd::linq::enumerable::first_or_default(self());
          }
          
          auto order() {
            return xtd::linq::enumerable::order(self());
          }

          auto order(const xtd::collections::generic::icomparer<source_t>& comparer) {
            return xtd::linq::enumerable::order(self(), comparer);
          }
          
          auto order_by(const std::function<source_t(const source_t&)>& key_selector) const {
            return xtd::linq::enumerable::order_by(self(), key_selector);
          }
          
          template<class key_t>
          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);
          }
          
          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<class key_t>
          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);
          }
          
          template<class result_t>
          auto select(const std::function<result_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select<result_t, source_t>(self(), selector);
          }

          auto select(const std::function<source_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select(self(), selector);
          }

          template<class result_t>
          auto select(const std::function<result_t(const source_t&, size_t index)>& selector) const {
            return xtd::linq::enumerable::select<result_t, source_t>(self(), selector);
          }

          auto select(const std::function<source_t(const source_t&, size_t index)>& selector) const {
            return xtd::linq::enumerable::select(self(), selector);
          }
          
          auto to_array() const noexcept -> xtd::array<source_t>;
          
          auto to_list() const noexcept -> list<source_t>;
          
          auto where(const std::function<bool(const source_t&)>& predicate) const {
            return xtd::linq::enumerable::where(self(), predicate);
          }

          auto where(const std::function<bool(const source_t&, size_t)>& 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"