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 "typeof.hpp"
#include <span>
#include <type_traits>
#include <vector>

namespace xtd {
  template<typename type_t, xtd::usize extent>
  class span : public xtd::object, public xtd::iequatable<xtd::span<type_t, extent>>, public xtd::collections::generic::ienumerable<type_t> {
  public:
    
    using element_type = type_t;
    using value_type = std::remove_cv_t<type_t>;
    using size_type = xtd::usize;
    using difference_type = xtd::ptrdiff;
    using pointer = type_t*;
    using const_pointer = const type_t*;
    using reference = type_t&;
    using const_reference = const type_t&;
    
    
    template <xtd::usize count = 0>
    constexpr span() : data_ {xtd::null}, length_ {0} {}
    
    template<typename iterator_t>
    constexpr span(iterator_t first, iterator_t last) : data_ {const_cast<pointer>(&(*first))}, length_ {extent != dynamic_extent ? extent : static_cast<size_type>(std::distance(first, last))} {}
    /* Conflict with span(collection_t& items, xtd::usize count)
    template<typename iterator_t>
    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 span(std::type_identity_t<element_type> (&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
    #else
    template<xtd::usize len>
    constexpr span(element_type(&array)[len]) noexcept : data_ {const_cast<element_type*>(array)}, length_ {extent != dynamic_extent ? extent : len} {}
    #endif
    template<typename array_type_t, xtd::usize len>
    constexpr span(const std::array<array_type_t, len>& array) noexcept : data_ {array.data()}, length_ {extent != dynamic_extent ? extent : len} {}
    template<typename array_type_t, xtd::usize len>
    constexpr span(std::array<array_type_t, len>& array) noexcept : data_ {array.data()}, length_ {extent != dynamic_extent ? extent : len} {}
    template<typename array_type_t>
    constexpr span(const xtd::array<array_type_t>& items) : span {items, size_type {0}, items.length()} {}
    template<typename array_type_t>
    constexpr span(xtd::array<array_type_t>& items) : span {items, size_type {0}, items.length()} {}
    #if defined(__xtd__cpp_lib_ranges)
    template<typename range_t>
    constexpr 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 span(range_t&& range) noexcept : data_ {range.data()}, length_ {extent != dynamic_extent ? extent : range.size()} {}
    #endif
    #if __cplusplus >= 202002l
    constexpr span(std::initializer_list<type_t> items) noexcept requires std::is_const_v<element_type> : data_ {items.begin()}, length_ {extent != dynamic_extent ? extent : items.size()} {}
    #else
    constexpr span(std::initializer_list<type_t> items) noexcept : data_ {const_cast<type_t*>(items.begin())}, length_ {extent != dynamic_extent ? extent : items.size()} {
      static_assert(std::is_const_v<element_type>, "type_t must be const");
    }
    #endif
    /* Conflict with span(range_t&& range) noexcept
    template<typename collection_t>
    constexpr span(collection_t& items) noexcept : span {items, size_type {0}, items.size()} {}
     */
    template<typename collection_t>
    constexpr span(collection_t& items, size_type length) : span {items, size_type {0}, length} {}
    template<typename collection_t>
    constexpr span(collection_t& items, size_type start, size_type length) : data_ {const_cast<pointer>(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 span(type_t* const data, size_type length) : data_ {const_cast<pointer>(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 span(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 span(const std::span<type_t, extent_>& s) : data_ {s.data()}, length_ {s.size()} {}
 
    constexpr span(span&& items) = default;
    constexpr span(const span& items) = default;
    
    auto operator =(span&& items) -> span& = default;
    auto operator =(const span& items) -> span& = default;
    
    
    static const span empty_span;
    
    
    [[nodiscard]] constexpr auto data() const noexcept -> const_pointer {return data_;}
    [[nodiscard]] constexpr auto data() noexcept -> 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);}
    
    
    auto clear() noexcept -> void {
      for (auto& item : *this)
        item = 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<span<value_type>>(obj) && equals(static_cast<const span<value_type>& > (obj));}
    [[nodiscard]] auto equals(const span& rhs) const noexcept -> bool override {return length() == rhs.length() && data() == rhs.data();}
    
    auto fill(const type_t& value) -> void {
      for (auto& item : *this)
        item = value;
    }
    
    template<xtd::usize count>
    [[nodiscard]] auto first() const -> span<type_t, count> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t, count> {data_, count};
    }

    [[nodiscard]] auto first(xtd::usize count) const -> span<type_t> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t> {data_, count};
    }
    
    auto get_enumerator() const -> xtd::collections::generic::enumerator<type_t> override {
      class span_enumerator : public xtd::collections::generic::ienumerator<type_t> {
      public:
        explicit 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<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 -> span<type_t, count> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t, count> {data_ + length_ - count, count};
    }

    [[nodiscard]] auto last(xtd::usize count) const -> span<type_t> {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t> {data_ + length_ - count, count};
    }
    
    template<xtd::usize start, size_type lenght = xtd::dynamic_extent>
    [[nodiscard]] auto slice() const -> span<type_t> {
      return lenght == xtd::dynamic_extent ? slice(start) : slice(start, lenght);
    }
    
    [[nodiscard]] auto slice(size_type start) const -> span<type_t> {
      return slice(start, length_ - start);
    }
    
    [[nodiscard]] auto slice(size_type start, size_type length) const -> span<type_t> {
      if (start > length_ || start + length > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t> {data_ + start, length};
    }
    
    template<xtd::usize offset, size_type count = xtd::dynamic_extent>
    [[nodiscard]] auto subspan() const -> 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 -> span<type_t> {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    [[nodiscard]] auto to_array() const noexcept -> xtd::array<value_type> {
      return data_ && length_ ? xtd::array<value_type>(data_, data_ + length_) : xtd::array<value_type> {};
    }
    
    [[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 [](size_type index) -> 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::index& index) -> reference {
      return operator[](index.get_offset(size()));
    }

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

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

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

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

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

    auto operator ()(const xtd::range& range) const -> xtd::read_only_span<type_t>;
    auto operator ()(const xtd::range& range) -> 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 span<type_t, extent> span<type_t, extent>::empty_span;
  
  // Deduction guides for xtd::span
  // {
  template<typename iterator_t>
  span(iterator_t, iterator_t) -> span<typename iterator_t::value_type>;
  
  template<typename type_t, xtd::usize len>
  span(type_t (&)[len]) noexcept -> span<type_t>;
  
  template< class type_t, xtd::usize len>
  span(const std::array<type_t, len>&) noexcept -> span<const type_t>;
  
  template< class type_t, xtd::usize len>
  span(std::array<type_t, len>&) noexcept -> span<type_t>;
  
  template<xtd::iterable iterable_t>
  span(iterable_t&& items) -> span<xtd::iterable_value_type<iterable_t>>;
 
  template<typename type_t>
  span(std::initializer_list<type_t>) noexcept -> span<const type_t>;
  
  template<typename collection_t>
  span(const collection_t& items) noexcept -> span<const typename collection_t::value_type>;
  
  template<typename collection_t>
  span(const collection_t&, xtd::usize) -> span<const typename collection_t::value_type>;
  
  template<typename collection_t>
  span(collection_t&, xtd::usize) -> span<typename collection_t::value_type>;
  
  template<typename collection_t>
  span(const collection_t&, xtd::usize, xtd::usize) -> span<const typename collection_t::value_type>;
  
  template<typename collection_t>
  span(collection_t&, xtd::usize, xtd::usize) -> span<typename collection_t::value_type>;
  
  template<typename collection_t>
  span(const collection_t&, const xtd::range&) -> span<const typename collection_t::value_type>;
 
  template<typename type_t>
  span(type_t* const, xtd::usize) -> 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) -> xtd::span<type_t> {
  return xtd::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) -> xtd::span<type_t> {
  return xtd::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) -> xtd::span<type_t> {
  return xtd::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) -> xtd::span<type_t> {
  return xtd::span<type_t>(*this, range);
}