enumerable.hpp

Go to the documentation of this file.

 
#pragma once
#include "../../../linq/enumerable.hpp"
 
namespace xtd {
  namespace collections {
    namespace generic {
      namespace extensions {
        template <typename enumerable_t, typename source_t>
        class enumerable {
        public:
          
          source_t aggregate(const std::function<source_t(const source_t&, const source_t&)>& func) const {
            return xtd::linq::enumerable::aggregate(base(), func);
          }
          template<typename func_t>
          source_t aggregate(const func_t& func) const {
            return xtd::linq::enumerable::aggregate(base(), func);
          }
          template<typename 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);
          }
          template<typename accumulate_t, typename func_t>
          accumulate_t aggregate(const accumulate_t& seed, const func_t& func) const {
            return xtd::linq::enumerable::aggregate(base(), seed, func);
          }
          template<typename accumulate_t, typename result_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);
          }
          template<typename accumulate_t, typename result_t, typename func_t, typename result_selector_t>
          result_t aggregate(const accumulate_t& seed, const func_t& func, const result_selector_t& result_selector) const {
            return xtd::linq::enumerable::aggregate(base(), seed, func, result_selector);
          }
          template<typename accumulate_t, typename func_t, typename result_selector_t>
          accumulate_t aggregate(const accumulate_t& seed, const func_t& func, const result_selector_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);
          }
          template<typename predicate_t>
          bool all(const predicate_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);
          }
          template<typename predicate_t>
          bool any(const predicate_t& predicate) const {
            return xtd::linq::enumerable::any(base(), predicate);
          }
          
          const xtd::collections::generic::ienumerable<source_t>& append(const source_t& element) const noexcept {
            return xtd::linq::enumerable::append(base(), element);
          }
 
          const xtd::collections::generic::ienumerable<source_t>& as_enumerable() const noexcept {
            return xtd::linq::enumerable::as_enumerable(base());
          }
 
          auto average() const noexcept {
            return xtd::linq::enumerable::average(base());
          }
          
          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<typename result_t>
          const xtd::collections::generic::ienumerable<result_t>& select(const std::function<result_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select<source_t, result_t>(base(), selector);
          }
          template<typename result_t, typename selector_t>
          const xtd::collections::generic::ienumerable<result_t>& select(const selector_t& selector) const {
            return xtd::linq::enumerable::select<source_t, result_t>(base(), selector);
          }
          const xtd::collections::generic::ienumerable<source_t>& select(const std::function<source_t(const source_t&)>& selector) const {
            return xtd::linq::enumerable::select(base(), selector);
          }
          template<typename selector_t>
          const xtd::collections::generic::ienumerable<source_t>& select(const selector_t& selector) const {
            return xtd::linq::enumerable::select(base(), selector);
          }
 
          const xtd::collections::generic::list<source_t>& to_list() const noexcept;
          
          const xtd::collections::generic::ienumerable<source_t>& where(const std::function<bool(const source_t&)>& predicate) const {
            return xtd::linq::enumerable::where(base(), predicate);
          }
          template<typename predicate_t>
          const xtd::collections::generic::ienumerable<source_t>& where(const predicate_t& predicate) const {
            return xtd::linq::enumerable::where(base(), predicate);
          }
          
        private:
          const enumerable_t& base() const noexcept {return static_cast<const enumerable_t&>(*this);}
        };
      }
    }
  }
}
 
#include "../../../linq/enumerable_collection.hpp"
#include "../ienumerable.hpp"