enumerable.hpp

Go to the documentation of this file.

#pragma once
#include "../collections/generic/helpers/allocator.hpp"
#include "../collections/generic/helpers/lesser.hpp"
#include "../collections/generic/helpers/raw_array.hpp"
//#include "../collections/generic/iequality_comparer.hpp"
#include "../collections/generic/comparer.hpp"
#include "../collections/generic/equality_comparer.hpp"
#include "../collections/generic/enumerator.hpp"
#define __XTD_STD_INTERNAL__
#include "../internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#define __XTD_CORE_INTERNAL__
#include "../internal/__array_definition.hpp"
#include "../internal/__key_value_pair_definition.hpp"
#include "../internal/__list_definition.hpp"
#undef  __XTD_CORE_INTERNAL__
#include "../decimal.hpp"
#include "../iequatable.hpp"
#include "../int32.hpp"
#include "../int64.hpp"
#include "../optional.hpp"
#include "../size.hpp"
#include "../static.hpp"
#include <algorithm>
#include <bitset>
#include <functional>
#include <queue>
#include <stack>

template<class type_t>
struct __opaque_xtd_linq_enumerable_collection__;
template<class type_t, class param_t>
struct __opaque_xtd_linq_lazy_enumerable__;

namespace xtd {
  namespace collections::generic {
    template<class type_t>
    class ienumerable;
  }
  
  namespace linq {
  
    class enumerable static_ {
    public:
      
      template<class type_t>
      using enumerator = typename xtd::collections::generic::enumerator<type_t>;
      
      template<class type_t>
      using iequality_comparer = typename xtd::collections::generic::iequality_comparer<type_t>;
      
      template<class type_t>
      using ienumerable = typename xtd::collections::generic::ienumerable<type_t>;
      
      template<class type_t>
      using list = typename xtd::collections::generic::list<type_t>;
      
      template<class key_t, class value_t>
      using key_value_pair = xtd::collections::generic::key_value_pair<key_t, value_t>;
      
      
      template<class source_t>
      inline static source_t aggregate(const ienumerable<source_t>& source, const std::function<source_t(const source_t&, const source_t&)>& func) {
        auto nb = 0;
        auto aggregated = source_t {};
        for (const auto& item : source)
          if (nb++ == 0) aggregated = item;
          else aggregated = func(aggregated, item);
        return aggregated;
      }

      template<class source_t>
      inline static source_t aggregate(const ienumerable<source_t>& source, const source_t& seed, const std::function<source_t(const source_t&, const source_t&)>& func) {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return aggregated;
      }

      template<class accumulate_t, class source_t>
      inline static accumulate_t aggregate(const ienumerable<source_t>& source, const accumulate_t& seed, const std::function<accumulate_t(const accumulate_t&, const source_t&)>& func) {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return aggregated;
      }

      template<class source_t>
      inline static source_t aggregate(const ienumerable<source_t>& source, 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) {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return result_selector(aggregated);
      }

      template<class result_t, class accumulate_t, class source_t>
      inline static result_t aggregate(const ienumerable<source_t>& source, 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) {
        auto aggregated = seed;
        for (const auto& item : source)
          aggregated = func(aggregated, item);
        return result_selector(aggregated);
      }
      
      template<class source_t>
      inline static bool all(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) {
        for (const auto& item : source)
          if (!predicate(item)) return false;
        return true;
      }
      
      template<class source_t>
      inline static bool any(const ienumerable<source_t>& source) noexcept {
        return source.begin() != source.end();
      }

      template<class source_t>
      inline static bool any(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) {
        for (const auto& item : source)
          if (predicate(item)) return true;
        return false;
      }
      
      template<class source_t>
      inline static auto append(const ienumerable<source_t>& source, const source_t& element) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        result.items.push_back(element);
        return result;
      }
      
      /*
      template<class source_t>
      inline static auto append(const ienumerable<source_t>& source, const source_t& element) noexcept {
        using param_type = std::tuple<source_t, enumerator<source_t>, source_t, bool>;
        auto result = __opaque_xtd_linq_lazy_enumerable__<source_t, param_type> {};
      
        result = __opaque_xtd_linq_lazy_enumerable__<source_t, param_type> {
          std::make_tuple(source_t {}, source.get_enumerator(), element, false),
          [](param_type& params) {
            auto& result = std::get<0>(params);
            auto& source_enumerator = std::get<1>(params);
            const auto& element = std::get<2>(params);
            auto& appended = std::get<3>(params);
      
            if (source_enumerator.move_next()) {
              result = source_enumerator.current();
              return true;
            }
      
            if (!appended) {
              appended = true;
              result = element;
              return true;
            }
      
            return false;
          },
          [](param_type& params) {
            auto& result = std::get<0>(params);
            auto& source_enumerator = std::get<1>(params);
            auto& appended = std::get<3>(params);
      
            result = source_t {};
            source_enumerator.reset();
            appended = false;
          }
        };
      
        return result;
      }*/
      
      template<class source_t>
      inline static const auto& as_enumerable(const ienumerable<source_t>& source) noexcept {
        return source;
      }

      template<class source_t>
      inline static auto as_enumerable(std::initializer_list<source_t> source) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(item);
        return result;
      }

      template<class collection_t>
      inline static auto as_enumerable(collection_t&& source) noexcept {
        #if defined(__xtd__cpp_lib_ranges)
        using source_t = std::ranges::range_value_t<collection_t>;
        #else
        using source_t = typename collection_t::value_type;
        #endif
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (auto&& item : source)
          result.items.push_back(item);
        return result;
      }

      template<class input_iterator_t>
      inline static auto as_enumerable(input_iterator_t first, input_iterator_t last) noexcept {
        using source_t = typename std::decay<decltype(*first)>::type;
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (auto iterator = first; iterator != last; ++iterator)
          result.items.push_back(*iterator);
        return result;
      }

      template<class input_iterator_t>
      inline static auto as_enumerable(input_iterator_t iterator, size_t length) noexcept {
        return as_enumerable(iterator, iterator + length);
      }

      template<class source_t, size_t length>
      inline static auto as_enumerable(const source_t (&array)[length]) noexcept {
        return as_enumerable(array, array + length);
      }
      
      template<xtd::size size_>
      inline static auto as_enumerable(std::bitset<size_> source); // defined in xtd/collections/bit_array.hpp
      template<class source_t, class container_t>
      inline static auto as_enumerable(std::queue<source_t, container_t> source) noexcept {
        struct std_queue : public std::queue<source_t> {
          std_queue(const std::queue<source_t>& queue) : ptr {reinterpret_cast<const std_queue*>(&queue)} {}
          auto begin() const {return ptr->c.begin();}
          auto end() const {return ptr->c.end();}
          const std_queue* ptr;
        };
        auto items = std_queue {source};
        return as_enumerable(items.begin(), items.end());
      }
      template<class source_t, class container_t>
      inline static auto as_enumerable(std::priority_queue<source_t, container_t> source) noexcept {
        struct std_priority_queue : public std::priority_queue<source_t> {
          std_priority_queue(const std::priority_queue<source_t>& queue) : ptr {reinterpret_cast<const std_priority_queue*>(&queue)} {}
          auto begin() const {return ptr->c.begin();}
          auto end() const {return ptr->c.end();}
          const std_priority_queue* ptr;
        };
        auto items = std_priority_queue {source};
        return as_enumerable(items.begin(), items.end());
      }
      template<class source_t, class container_t>
      inline static auto as_enumerable(std::stack<source_t, container_t> source) noexcept {
        struct std_stack : public std::stack<source_t> {
          std_stack(const std::stack<source_t>& stack) : ptr {reinterpret_cast<const std_stack*>(&stack)} {}
          auto begin() const {return ptr->c.begin();}
          auto end() const {return ptr->c.end();}
          const std_stack* ptr;
        };
        auto items = std_stack {source};
        return as_enumerable(items.begin(), items.end());
      }
      
      static xtd::decimal average(const ienumerable<xtd::decimal>& source);
      static double average(const ienumerable<double>& source);
      static float average(const ienumerable<float>& source);
      static double average(const ienumerable<xtd::int32>& source);
      static double average(const ienumerable<xtd::int64>& source);
      
      static xtd::optional<xtd::decimal> average(const ienumerable<xtd::optional<xtd::decimal >>& source) noexcept;
      static xtd::optional<double> average(const ienumerable<xtd::optional<double >>& source) noexcept;
      static xtd::optional<float> average(const ienumerable<xtd::optional<float >>& source) noexcept;
      static xtd::optional<double> average(const ienumerable<xtd::optional<xtd::int32 >>& source) noexcept;
      static xtd::optional<double> average(const ienumerable<xtd::optional<xtd::int64 >>& source) noexcept;
      
      template<class result_t, class source_t>
      inline static auto cast(const ienumerable<source_t>& source) noexcept; // Defined include/xtd/as.hpp
      
      template<class source_t>
      inline static auto chunk(const ienumerable<source_t>& source, xtd::size size); // Defined in include/xtd/array.hpp
      
      template<class source_t>
      inline static auto concat(const ienumerable<source_t>& first, const ienumerable<source_t>& second) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : first)
          result.items.push_back(item);
        for (const auto& item : second)
          result.items.push_back(item);
        return result;
      }
      
      template<class source_t>
      inline static bool contains(const ienumerable<source_t>& source, const source_t& value) noexcept {
        for (const auto& item : source)
          if (item == value) return true;
        return false;
      }
      
      template<class source_t>
      inline static bool contains(const ienumerable<source_t>& source, const source_t& value, const xtd::collections::generic::iequality_comparer<source_t>& comparer) noexcept {
        for (const auto& item : source)
          if (comparer.equals(item, value)) return true;
        return false;
      }
      
      template<class source_t>
      inline static xtd::size count(const ienumerable<source_t>& source) noexcept {
        auto count = xtd::size {0};
        auto enumerator = source.get_enumerator();
        while (enumerator.move_next()) ++count;
        return count;
      }
      
      template<class source_t>
      inline static xtd::size count(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) noexcept {
        return where<source_t>(source, predicate).count();
      }
      
      template<class source_t>
      inline static xtd::size count(const ienumerable<source_t>& source, const source_t& value) noexcept {
        return count<source_t>(source, [value](const source_t& item) -> bool {return item == value;});
      }
      
      template<class key_t, class source_t>
      inline static auto count_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) noexcept {
        return count_by(source, key_selector, xtd::collections::generic::equality_comparer<key_t>::default_equality_comparer());
      }
      
      template<class key_t, class source_t>
      inline static auto count_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector, const iequality_comparer<key_t>& key_comparer) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<key_value_pair<key_t, xtd::size>> {};
        auto keys = list<key_t> {};
        auto enumerator = source.get_enumerator();
        while (enumerator.move_next()) {
          auto key = key_selector(enumerator.current());
          auto index = size_t {0};
          for (; index < keys.count(); ++index)
            if (key_comparer.equals(keys[index], key)) break;
          if (index < keys.count()) result.items[index] = {key, result.items[index].value() + 1};
          else {
            keys.add(key);
            result.items.push_back({key, 1});
          }
        }
        return result;
      }
      
      template<class source_t>
      inline static auto default_if_empty(const ienumerable<source_t>& source) noexcept {
        return default_if_empty(source, source_t {});
      }
      
      template<class source_t>
      inline static auto default_if_empty(const ienumerable<source_t>& source, const source_t& default_value) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        if (!any(source)) result.items.push_back(default_value);
        else for (const auto& item : source)
            result.items.push_back(item);
        return result;
      }
      
      template<class source_t>
      inline static auto distinct(const ienumerable<source_t>& source) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          if (!contains(result, item))
            result.items.push_back(item);
        return result;
      }
      
      template<class source_t>
      inline static auto distinct(const ienumerable<source_t>& source, const xtd::collections::generic::iequality_comparer<source_t>& comparer) noexcept {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          if (!contains(result, item, comparer))
            result.items.push_back(item);
        return result;
      }
      
      template<class source_t>
      inline static source_t first_or_default(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate, const source_t& default_value) noexcept {
        const auto& result = where(source, predicate);
        return any(result) ? *result.begin() : default_value;
      }

      template<class source_t>
      inline static source_t first_or_default(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) noexcept {
        return first_or_default(source, predicate, source_t {});
      }

      template<class source_t>
      inline static source_t first_or_default(const ienumerable<source_t>& source, const source_t& default_value) noexcept {
        return any(source) ? *source.begin() : default_value;
      }

      template<class source_t>
      inline static source_t first_or_default(const ienumerable<source_t>& source) noexcept {
        return first_or_default(source, source_t {});
      }
      
      template<class source_t>
      inline static const auto& from(const ienumerable<source_t>& source) noexcept {
        return as_enumerable(source);
      }

      template<class source_t>
      inline static auto from(std::initializer_list<source_t> source) noexcept {
        return as_enumerable(source);
      }

      template<class collection_t>
      inline static auto from(collection_t&& source) noexcept {
        return as_enumerable(source);
      }

      template<class input_iterator_t>
      inline static auto from(input_iterator_t first, input_iterator_t last) noexcept {
        return as_enumerable(first, last);
      }

      template<class input_iterator_t>
      inline static auto from(input_iterator_t iterator, size_t length) noexcept {
        return as_enumerable(iterator, iterator + length);
      }

      template<class source_t, size_t length>
      inline static auto from(const source_t (&array)[length]) noexcept {
        return as_enumerable(array, array + length);
      }
      
      template<class source_t, class container_t>
      inline static auto from(std::queue<source_t, container_t> source) noexcept {
        return as_enumerable(source);
      }
      template<class source_t, class container_t>
      inline static auto from(std::stack<source_t, container_t> source) noexcept {
        return as_enumerable(source);
      }
      
      template<class source_t>
      inline static auto order(const ienumerable<source_t>& source) {
        return order(source, xtd::collections::generic::comparer<source_t>::default_comparer);
      }

      template<class source_t>
      inline static auto order(const ienumerable<source_t>& source, const xtd::collections::generic::icomparer<source_t>& comparer) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        result.items = xtd::collections::generic::helpers::raw_array<source_t> {source.begin(), source.end()};
        std::sort(result.items.begin(), result.items.end(), xtd::collections::generic::helpers::lesser<source_t>(comparer));
        return result;
      }
      
      template<class key_t, class source_t>
      inline static auto order_by(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        result.items = std::vector<source_t> {source.begin(), source.end()};
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) < key_selector(b);});
        return result;
      }
      
      template<class source_t>
      inline static auto order_by(const ienumerable<source_t>& source, const std::function<source_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        result.items = std::vector<source_t> {source.begin(), source.end()};
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) < key_selector(b);});
        return result;
      }
      
      template<class key_t, class source_t>
      inline static auto order_by_descending(const ienumerable<source_t>& source, const std::function<key_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        result.items = std::vector<source_t> {source.begin(), source.end()};
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) > key_selector(b);});
        return result;
      }
      
      template<class source_t>
      inline static auto order_by_descending(const ienumerable<source_t>& source, const std::function<source_t(const source_t&)>& key_selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        result.items = std::vector<source_t> {source.begin(), source.end()};
        std::sort(result.items.begin(), result.items.end(), [key_selector](const source_t& a, const source_t& b) {return key_selector(a) > key_selector(b);});
        return result;
      }
      
      template<class type_t>
      inline static auto range(type_t count) {
        auto step = type_t {};
        return range(type_t {}, count, ++step);
      }

      template<class type_t>
      inline static auto range(type_t start, type_t count) {
        auto step = type_t {};
        return range(start, count, ++step);
      }

      template<class type_t>
      inline static auto range(type_t start, type_t count, type_t step) {
        using param_type = std::tuple<type_t, type_t, type_t, type_t>;
        auto numbers = __opaque_xtd_linq_lazy_enumerable__<type_t, param_type> {};
        
        if (step == type_t {}) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
        if (count < type_t {}) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        
        numbers = __opaque_xtd_linq_lazy_enumerable__<type_t, param_type> {
          std::make_tuple(start, count, step, type_t {}),
          [](param_type & params) {
            auto& result = std::get<0>(params);
            auto& count = std::get<1>(params);
            auto& step = std::get<2>(params);
            auto& index = std::get<3>(params);
            if (index != 0) result += step;
            return index++ < count;
          },
          [start, count, step](param_type & params) {
            params = std::make_tuple(start, count, step, type_t {});
          }
        };
        return numbers;
      }
      
      template<class result_t, class source_t>
      inline static auto select(const ienumerable<source_t>& source, const std::function<result_t(const source_t&)>& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<result_t> {};
        for (const auto& item : source)
          result.items.push_back(selector(item));
        return result;
      }

      template<class source_t>
      inline static auto select(const ienumerable<source_t>& source, const std::function<source_t(const source_t&)>& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          result.items.push_back(selector(item));
        return result;
      }

      template<class result_t, class source_t>
      inline static auto select(const ienumerable<source_t>& source, const std::function<result_t(const source_t&, xtd::size)>& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<result_t> {};
        auto index = xtd::size {0};
        for (const auto& item : source)
          result.items.push_back(selector(item, index++));
        return result;
      }

      template<class source_t>
      inline static auto select(const ienumerable<source_t>& source, const std::function<source_t(const source_t&, xtd::size)>& selector) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        auto index = xtd::size {0};
        for (const auto& item : source)
          result.items.push_back(selector(item, index++));
        return result;
      }
      
      template<class source_t>
      inline static auto to_array(const ienumerable<source_t>& source) noexcept; // Defined in include/xtd/array.hpp
      
      template<class source_t>
      inline static auto to_list(const ienumerable<source_t>& source) noexcept; // Defined in include/xtd/collections/generic/list.hpp
      
      template<class source_t>
      inline static auto where(const ienumerable<source_t>& source, const std::function<bool(const source_t&)>& predicate) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        for (const auto& item : source)
          if (predicate(item)) result.items.push_back(item);
        return result;
      }

      template<class source_t>
      inline static auto where(const ienumerable<source_t>& source, const std::function<bool(const source_t&, xtd::size)>& predicate) {
        auto result = __opaque_xtd_linq_enumerable_collection__<source_t> {};
        auto index = xtd::size {0};
        for (const auto& item : source)
          if (predicate(item, index++)) result.items.push_back(item);
        return result;
      }

    };
  }
}
 
#include "../collections/generic/extensions/enumerable.hpp"
#include "from.hpp"