range.hpp

Go to the documentation of this file.

#pragma once
#include "index.hpp"
#include "object.hpp"
#include "usize.hpp"
#include "usize_object.hpp"
#include "npos.hpp"
#include "linq/enumerable.hpp"
#include <vector>

namespace xtd {
  class range : public xtd::object, xtd::iequatable<range> {
  public:
    
    using index_type = xtd::index;
    
    using size_type = xtd::usize;
    
    
    range() noexcept = default;
    range(const index_type& start, const index_type& end) noexcept : start_{start}, end_{end} {}
    range(xtd::integer auto start, const xtd::integer auto end) noexcept : start_{start}, end_{end} {}
    
    
    [[nodiscard]] constexpr auto end() const noexcept -> const index_type& {return end_;}
    [[nodiscard]] constexpr auto start() const noexcept -> const index_type& {return start_;}
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return is<range>(obj) && equals(static_cast<const range& > (obj));}
    [[nodiscard]] auto equals(const range& value) const noexcept -> bool override {return xtd::collections::generic::helpers::equator<index_type> {}(start_, value.start_) && xtd::collections::generic::helpers::equator<index_type> {}(end_, value.end_);}
    
    [[nodiscard]] auto get_hash_code() const noexcept -> size_type override {return hash_code::combine(start_, end_);}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return xtd::string::format("{}..{}", start_, end_);}
    
    [[nodiscard]] static auto all() noexcept -> xtd::range {return range {xtd::index::start, xtd::index::end};}
    
    [[nodiscard]] static auto end_at(index_type end) noexcept -> xtd::range {return range {xtd::index::start, end};}
    [[nodiscard]] static auto end_at(xtd::integer auto end) noexcept -> xtd::range {return range {xtd::index::start, xtd::index {end}};}

    [[nodiscard]] static auto start_at(index_type start) noexcept -> xtd::range {return range {start, xtd::index::end};}
    [[nodiscard]] static auto start_at(xtd::integer auto start) noexcept -> xtd::range {return range {xtd::index {start}, xtd::index::end};}
  
  private:
    index_type start_ = index_type {0};
    index_type end_ = index_type {0};
  };
}

template<xtd::iterable source_t>
auto xtd::linq::enumerable::take(source_t&& source, const xtd::range& range) -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>> {
  //auto source_holder = enumerable_holder<source_t> {std::forward<source_t>(source)};
  //return invoke_take_with_range(source_holder.get(), range);
  return invoke_take_with_range(source, range);
}
 
template<typename source_t>
requires(!requires (const xtd::raw_type<source_t>& source) {{source.size()} -> std::convertible_to<std::size_t>;})
auto xtd::linq::enumerable::invoke_take_with_range(source_t&& source, const xtd::range& range) -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>> {
  //auto source_holder = enumerable_holder<source_t> {std::forward<source_t>(source)};
  //auto result = list<xtd::iterable_value_type<source_t>> {source_holder.get()};
  auto result = std::vector<xtd::iterable_value_type<source_t>> {source.begin(), source.end()};
  return invoke_take_with_range(result, range);
}
 
template<typename source_t>
requires(requires (const xtd::raw_type<source_t>& source) {{source.size()} -> std::convertible_to<std::size_t>;})
auto xtd::linq::enumerable::invoke_take_with_range(source_t&& source, const xtd::range& range) -> xtd::collections::generic::enumerable_generator<xtd::iterable_value_type<source_t>> {
  auto index = xtd::usize {0};
  auto skip = range.start();
  auto count = skip + range.end() - range.start();
  //if (range.end() )
  //auto source_holder = enumerable_holder<xtd::raw_type<source_t>> {std::forward<source_t>(source)};
  //for (const auto& item : source_holder.get())
  for (const auto& item : source) {
    if (index++ < skip) continue;
    if (index++ == count) break;
    co_yield item;
  }
}