read_only_span.hpp

Go to the documentation of this file.

#pragma once
#define __XTD_CORE_INTERNAL__
#include "internal/__span_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#include "collections/generic/helpers/raw_array.hpp"
#include "collections/generic/helpers/wrap_pointer_iterator.hpp"
#include "collections/generic/enumerable.hpp"
#include "array.hpp"
#include "dynamic_extent.hpp"
#include "iequatable.hpp"
#include "index.hpp"
#include "is.hpp"
#include "iterable.hpp"
#include "iterable_value_type.hpp"
#include "null.hpp"
#include "object.hpp"
#include "ptrdiff.hpp"
#include "range.hpp"
#include "views/views.hpp"
#include "span.hpp"
#include "typeof.hpp"
#include <type_traits>
#include <vector>

namespace xtd {
  template<typename type_t, xtd::usize extent>
  class read_only_span : public xtd::object, public xtd::iequatable<xtd::read_only_span<type_t, extent>>, public xtd::collections::generic::ienumerable<type_t> {
  public:
    
    using element_type = std::add_const_t<type_t>;
    using value_type = type_t;
    using size_type = xtd::usize;
    using difference_type = xtd::ptrdiff;
    using pointer = const type_t*;
    using const_pointer = const type_t*;
    using reference = const type_t&;
    using const_reference = const type_t&;
    
    
    template <xtd::usize count = 0>
    constexpr read_only_span() : data_ {xtd::null}, length_ {0} {}
    
    template<typename iterator_t>
    constexpr read_only_span(iterator_t first, iterator_t last) : data_ { & (*first)}, length_ {extent != dynamic_extent ? extent : static_cast<size_type>(std::distance(first, last))} {}
    /* Conflict with read_only_span(collection_t& items, xtd::usize count)
    template<typename iterator_t>
    read_only_span(iterator_t first, xtd::usize count) : data_ {&(*first)}, length_ {extent != dynamic_extent ? extent : count} {}
     */
    #if defined(__xtd__cpp_lib_type_identity)
    template<xtd::usize len>
    constexpr read_only_span(const std::type_identity_t<element_type> (&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
    #else
    template<xtd::usize len>
    constexpr read_only_span(const element_type(&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
    #endif
    template<typename array_type_t, xtd::usize len>
    constexpr read_only_span(const std::array<array_type_t, len>& array) noexcept : data_ {array.data()}, length_ {extent != dynamic_extent ? extent : len} {}
    template<typename array_type_t>
    constexpr read_only_span(const xtd::array<array_type_t>& items) : read_only_span {items, size_type {0}, items.length()} {}
    #if defined(__xtd__cpp_lib_ranges)
    template<typename range_t>
    constexpr read_only_span(range_t&& range) noexcept : data_ {std::ranges::data(range)}, length_ {extent != dynamic_extent ? extent : std::ranges::size(range)} {}
    #else
    template<typename range_t>
    constexpr read_only_span(range_t&& range) noexcept : data_ {range.data()}, length_ {extent != dynamic_extent ? extent : range.size()} {}
    #endif
    constexpr read_only_span(std::initializer_list<type_t> items) noexcept : data_ {items.begin()}, length_ {extent != dynamic_extent ? extent : items.size()} {}
    /* Conflict with read_only_span(range_t&& range) noexcept
    template<typename collection_t>
    constexpr read_only_span(collection_t& items) noexcept : span {items, size_type {0}, items.size()} {}
     */
    template<typename collection_t>
    constexpr read_only_span(const collection_t& items, size_type length) : read_only_span {items, size_type {0}, length} {}
    template<typename collection_t>
    constexpr read_only_span(const collection_t& items, size_type start, size_type length) : data_ {items.data() + start}, length_ {extent != dynamic_extent ? extent : length} {
      if (start + length > items.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
    }

    constexpr read_only_span(const type_t* data, size_type length) : data_ {data}, length_ {extent != dynamic_extent ? extent : length} {
      if (!data) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
    }

    template<typename collection_t>
    constexpr read_only_span(const collection_t& items, const xtd::range& range) {
      auto [start, length] = range.get_offset_and_length(items.size());
      data_ = items.data() + start;
      length_ = extent != dynamic_extent ? extent : length;
    }

    
    template<xtd::usize extent_>
    constexpr read_only_span(const std::span<type_t, extent_>& s) : data_ {s.data()}, length_ {s.size()} {}
    
    constexpr read_only_span(read_only_span&& items) = default;
    constexpr read_only_span(const read_only_span& items) = default;
    
    auto operator =(read_only_span&& items) -> read_only_span& = default;
    auto operator =(const read_only_span& items) -> read_only_span& = default;
        
    
    static const read_only_span empty_read_only_span;

    
    [[nodiscard]] constexpr auto data() const noexcept -> const_pointer {return data_;}
    
    [[nodiscard]] constexpr auto empty() const noexcept -> bool {return is_empty();}
    
    [[nodiscard]] constexpr auto is_empty() const noexcept -> bool {return !length_;}
    
    [[nodiscard]] constexpr auto length() const noexcept -> size_type {return length_;}
    
    [[nodiscard]] constexpr auto size() const noexcept -> size_type {return length();}
    
    [[nodiscard]] constexpr auto size_bytes() const noexcept -> size_type {return length_ * sizeof(value_type);}
    
    
    template<xtd::usize length>
    auto copy_to(span<type_t, length>& destination) const -> void {
      if (!try_copy_to(destination))
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
    }
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return is<read_only_span<value_type>>(obj) && equals(static_cast<const read_only_span<value_type>& > (obj));}
    [[nodiscard]] auto equals(const read_only_span& rhs) const noexcept -> bool override {return length() == rhs.length() && data() == rhs.data();}
    
    template<xtd::usize count>
    [[nodiscard]] auto first() const -> read_only_span<type_t, count> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return read_only_span<type_t, count> {data_, count};
    }

    [[nodiscard]] auto first(xtd::usize count) const -> read_only_span<type_t> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return read_only_span<type_t> {data_, count};
    }
    
    auto get_enumerator() const -> xtd::collections::generic::enumerator<type_t> override {
      class read_only_span_enumerator : public xtd::collections::generic::ienumerator<type_t> {
      public:
        explicit read_only_span_enumerator(const_pointer data, xtd::usize length) : data_(data), length_(length) {}
        const type_t& current() const override {return *(data_ + index_);}
        bool move_next() override {return ++index_ < length_;}
        void reset() override {index_ = xtd::npos;}
        
      protected:
        const_pointer data_;
        xtd::usize length_;
        xtd::usize index_ = xtd::npos;
      };
      return {new_ptr<read_only_span_enumerator>(data_, length_)};
    }

    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {
      auto result = hash_code {};
      for (const auto& item : *this)
        result.add(item);
      return result.to_hash_code();
    }
    
    template<xtd::usize count>
    [[nodiscard]] auto last() const -> read_only_span<type_t, count> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return read_only_span<type_t, count> {data_ + length_ - count, count};
    }

    [[nodiscard]] auto last(xtd::usize count) const -> read_only_span<type_t> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return read_only_span<type_t> {data_ + length_ - count, count};
    }
    
    template<xtd::usize start, size_type lenght = xtd::dynamic_extent>
    [[nodiscard]] auto slice() const -> read_only_span<type_t> {
      return lenght == xtd::dynamic_extent ? slice(start) : slice(start, lenght);
    }
    
    [[nodiscard]] auto slice(size_type start) const -> read_only_span<type_t> {
      return slice(start, length_ - start);
    }
    
    [[nodiscard]] auto slice(size_type start, size_type length) const -> read_only_span<type_t> {
      if (start > length_ || start + length > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return read_only_span<type_t> {data_ + start, length};
    }
    
    template<xtd::usize offset, size_type count = xtd::dynamic_extent>
    [[nodiscard]] auto subspan() const -> read_only_span<type_t> {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    [[nodiscard]] auto subspan(size_type offset, size_type count = xtd::dynamic_extent) const -> read_only_span<type_t> {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    [[nodiscard]] auto to_array() const noexcept -> xtd::array<std::remove_cv_t<type_t>> {
      return data_ && length_ ? xtd::array<std::remove_cv_t<type_t>>(data_, data_ + length_) : xtd::array<std::remove_cv_t<type_t >> {};
    }
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string  override {
      if (typeof_<type_t>() == typeof_<char>()) return xtd::string::join("", *this);
      return xtd::string::format("[{}]", xtd::string::join(", ", *this));
    }
    
    template<xtd::usize length>
    auto try_copy_to(span<type_t, length>& destination) const noexcept -> bool {
      if (destination.length() < this->length()) return false;
      for (auto index = xtd::usize {}; index < length_; ++index)
        destination[index] = operator [](index);
      return true;
    }

    
    
    auto operator[](size_type index) const -> const_reference {
      if (index >= length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return *(data_ + index);
    }

    auto operator [](const xtd::index& index) const -> const_reference {
      return operator[](index.get_offset(size()));
    }

    auto operator [](const xtd::range& range) const -> read_only_span {
      return read_only_span {*this, range};
    }

    auto operator ()(size_type index) const -> const_reference {
      return operator[](index);
    }

    auto operator ()(const xtd::index& index) const -> const_reference {
      return operator[](index);
    }

    auto operator ()(const xtd::range& range) const -> read_only_span {
      return operator[](range);
    }


    operator std::span<type_t, extent>() const {return std::span<type_t, extent>(data_, length_);}
 
  private:
    pointer data_ = null;
    size_type length_ = size_type {};
  };
  
  template<typename type_t, xtd::usize extent>
  inline const read_only_span<type_t, extent> read_only_span<type_t, extent>::empty_read_only_span;
  
  // Deduction guides for xtd::read_only_span
  // {
  template<typename iterator_t>
  read_only_span(iterator_t first, iterator_t last) -> read_only_span<typename iterator_t::value_type>;
  
  template<typename type_t, xtd::usize len>
  read_only_span(const type_t (&array)[len]) -> read_only_span<type_t>;
  
  template< class type_t, xtd::usize len>
  read_only_span(const std::array<type_t, len>& array) -> read_only_span<type_t>;
  
  template<xtd::iterable iterable_t>
  read_only_span(iterable_t&& items) -> read_only_span<xtd::iterable_value_type<iterable_t>>;
  
  template<typename collection_t>
  read_only_span(const collection_t& items) -> read_only_span<typename collection_t::value_type>;
  
  template<typename collection_t>
  read_only_span(const collection_t& items, xtd::usize) -> read_only_span<typename collection_t::value_type>;
  
  template<typename collection_t>
  read_only_span(const collection_t& items, xtd::usize, xtd::usize) -> read_only_span<typename collection_t::value_type>;
  
  template<typename collection_t>
  read_only_span(const collection_t&, const xtd::range&) -> read_only_span<const typename collection_t::value_type>;
 
  template<typename type_t>
  read_only_span(const type_t* data, xtd::usize size) -> read_only_span<type_t>;
  // }
}

template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator [](const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return xtd::read_only_span<type_t>(self(), range);
}
 
template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator ()(const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return xtd::read_only_span<type_t>(self(), range);
}
 
template<typename type_t, typename allocator_t>
auto xtd::collections::generic::helpers::raw_array<type_t, allocator_t>::operator [](const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return xtd::read_only_span<type_t>(*this, range);
}
 
template<typename type_t, typename allocator_t>
auto xtd::collections::generic::helpers::raw_array<type_t, allocator_t>::operator ()(const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return xtd::read_only_span<type_t>(*this, range);
}
 
template<typename type_t, xtd::usize extent>
auto xtd::span<type_t, extent>::operator [](const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return xtd::read_only_span<type_t> {*this, range};
}
 
template<typename type_t, xtd::usize extent>
auto xtd::span<type_t, extent>::operator ()(const xtd::range& range) const -> xtd::read_only_span<type_t> {
  return operator[](range);
}