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>;
          
          
          source_t aggregate(const std::function<source_t(const source_t&, const source_t&)>& func) const {
            return xtd::linq::enumerable::aggregate(base(), func);
          }
          source_t aggregate(const source_t& seed, const std::function<source_t(const source_t&, const source_t&)>& func) const {
            return xtd::linq::enumerable::aggregate(base(), seed, func);
          }
          template<class accumulate_t>
          accumulate_t aggregate(const accumulate_t& seed, const std::function<accumulate_t(const source_t&, const accumulate_t&)>& func) const {
            return xtd::linq::enumerable::aggregate(base(), seed, func);
          }
          source_t 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 {
            return xtd::linq::enumerable::aggregate(base(), seed, func, result_selector);
          }
          template<class result_t, class accumulate_t>
          result_t aggregate(const accumulate_t& seed, const std::function<accumulate_t(const source_t&, const accumulate_t&)>& func, const std::function<result_t(const accumulate_t&)>& result_selector) const {
            return xtd::linq::enumerable::aggregate(base(), seed, func, result_selector);
          }
 
          bool all(const std::function<bool(const source_t&)>& predicate) const {
            return xtd::linq::enumerable::all(base(), predicate);
          }
          
          bool any() const noexcept {
            return xtd::linq::enumerable::any(base());
          }
          bool any(const std::function<bool(const source_t&)>& predicate) const {
            return xtd::linq::enumerable::any(base(), predicate);
          }
          
          const ienumerable<source_t>& append(const source_t& element) const noexcept {
            return xtd::linq::enumerable::append(base(), element);
          }
 
          const ienumerable<source_t>& as_enumerable() const noexcept {
            return xtd::linq::enumerable::as_enumerable(base());
          }
 
          auto average() const noexcept {
            return xtd::linq::enumerable::average(base());
          }
          
          template <class result_t>
          const ienumerable<result_t>& cast() const noexcept {
            return xtd::linq::enumerable::cast<result_t>(base());
          }
 
          const ienumerable<xtd::array<source_t>>& chunk(size_t size) const {
            return xtd::linq::enumerable::chunk(base(), size);
          }
 
          const ienumerable<source_t>& concat(const ienumerable<source_t>& second) const noexcept {
            return xtd::linq::enumerable::concat(base(), second);
          }
 
          bool contains(const source_t& value) const noexcept {
            return xtd::linq::enumerable::contains(base(), value);
          }
          
          bool contains(const source_t& value, const xtd::collections::generic::iequality_comparer<source_t>& comparer) const noexcept {
            return xtd::linq::enumerable::contains(base(), value, comparer);
          }
 
          size_t count() const noexcept {
            return xtd::linq::enumerable::count(base());
          }
          
          size_t count(const std::function<bool(const source_t&)>& predicate) const noexcept {
            return xtd::linq::enumerable::count(base(), predicate);
          }
          
          template <class key_t>
          const ienumerable<key_value_pair<key_t, xtd::size>>& count_by(const std::function<key_t(const source_t&)>& key_selector) const noexcept {
            return xtd::linq::enumerable::count_by<key_t, source_t>(base(), key_selector);
          }
          
          template <class key_t>
          const ienumerable<key_value_pair<key_t, xtd::size>>& 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>(base(), key_selector, key_comparer);
          }
          
          const ienumerable<source_t>& default_if_empty() const noexcept {
            return xtd::linq::enumerable::default_if_empty(base());
          }
          
          const ienumerable<source_t>& default_if_empty(const source_t& default_value) const noexcept {
            return xtd::linq::enumerable::default_if_empty(base(), default_value);
          }
 
          source_t first_or_default(const std::function<bool(const source_t&)>& predicate, const source_t& default_value) const noexcept {
            return xtd::linq::enumerable::first_or_default(base(), predicate, default_value);
          }
          source_t first_or_default(const std::function<bool(const source_t&)>& predicate) const noexcept {
            return xtd::linq::enumerable::first_or_default(base(), predicate);
          }
 
          source_t first_or_default(const source_t default_value) const noexcept {
            return xtd::linq::enumerable::first_or_default(base(), default_value);
          }
          
          source_t first_or_default() const noexcept {
            return xtd::linq::enumerable::first_or_default(base());
          }
 
          template<class result_t>
          const ienumerable<result_t>& select(const std::function<result_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select<result_t, source_t>(base(), selector);
          }
          const ienumerable<source_t>& select(const std::function<source_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select(base(), selector);
          }
          template<class result_t>
          const ienumerable<result_t>& select(const std::function<result_t(const source_t&, size_t index)>& selector) const {
            return xtd::linq::enumerable::select<result_t, source_t>(base(), selector);
          }
          const ienumerable<source_t>& select(const std::function<source_t(const source_t&, size_t index)>& selector) const {
            return xtd::linq::enumerable::select(base(), selector);
          }
 
          const list<source_t>& to_list() const noexcept;
          
          const ienumerable<source_t>& where(const std::function<bool(const source_t&)>& predicate) const {
            return xtd::linq::enumerable::where(base(), predicate);
          }
          const ienumerable<source_t>& where(const std::function<bool(const source_t&, size_t)>& predicate) const {
            return xtd::linq::enumerable::where(base(), predicate);
          }
          
        private:
          const enumerable_t& base() const noexcept {return static_cast<const enumerable_t&>(*this);}
        };
      }
    }
  }
}
 
#define __XTD_CORE_INTERNAL__
#include "../../../internal/__enumerable_collection.hpp"
#undef __XTD_CORE_INTERNAL__
#include "../ienumerable.hpp"