range.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/throw_helper.hpp"
#include "basic_string_view.hpp"
#include "index.hpp"
#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;
    
    
    struct offset_and_length {
      size_type start = 0;
      size_type length = 0;
    };


    
    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_offset_and_length(size_type length) const -> offset_and_length {
      auto start = start_.get_offset(length);
      auto end = end_.get_offset(length);
      if (end > length || start > end) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return {.start = start, .length = end - start};
    }

    [[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 parse(const xtd::string& value) -> xtd::range {
      auto result = range {};
      if (!try_parse(value, result)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);
      return result;
    }

    [[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};}
    
    [[nodiscard]] static auto try_parse(const xtd::string& value, xtd::range& result) noexcept -> bool {
      auto indexes = value.split('.');
      if (indexes.length() != 3 && !xtd::string::is_empty(indexes[1])) return false;
      if (!xtd::index::try_parse(indexes[0], result.start_)) return false;
      if (!xtd::index::try_parse(indexes[2], result.end_)) return false;
      return true;
    }

  
  private:
    index_type start_ = index_type {0};
    index_type end_ = index_type {0};
  };
}
 
#include "literals/range.hpp"

template<typename char_t, typename traits_t, typename allocator_t>
auto xtd::basic_string<char_t, traits_t, allocator_t>::operator [](const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t> {
  //return xtd::basic_read_only_string_view<type_t>(self(), range);
  auto [start, length] = range.get_offset_and_length(size());
  return xtd::basic_read_only_string_view<char_t> {chars_.begin() + start, chars_.begin() + start + length};
}
 
template<typename char_t, typename traits_t, typename allocator_t>
auto xtd::basic_string<char_t, traits_t, allocator_t>::operator ()(const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t> {
  return operator [](range);
}
 
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>> {
  if (range.start().is_from_end() || range.end().is_from_end()) {
    auto safe_source = std::vector<xtd::iterable_value_type<source_t>> {source.begin(), source.end()};
    for (const auto& item : xtd::span<xtd::iterable_value_type<source_t>>{safe_source, range})
      co_yield item;
  } else {
    auto index = xtd::usize {0};
    auto skip = range.start().value();
    auto end = range.end().value();
    //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 - 1 == end) break;
      co_yield item;
    }
  }
}