span.hpp

Go to the documentation of this file.

 
#pragma once
#define __XTD_STD_INTERNAL__
#include "internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#include "collections/generic/helpers/wrap_pointer_iterator.hpp"
#include "argument_null_exception.hpp"
#include "argument_out_of_range_exception.hpp"
#include "array.hpp"
#include "dynamic_extent.hpp"
#include "iequatable.hpp"
#include "index_out_of_range_exception.hpp"
#include "is.hpp"
#include "null.hpp"
#include "object.hpp"
#include "ptrdiff.hpp"
#include "ranges.hpp"
#include "typeof.hpp"
#include <type_traits>
#include <vector>
 
namespace xtd {
  template<class type_t, xtd::size extent = dynamic_extent>
  class span : public xtd::object, public xtd::iequatable<xtd::span<type_t, extent>> {
  public:
    
    using element_type = type_t;
    using value_type = std::remove_cv_t<type_t>;
    using size_type = xtd::size;
    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&;
    using iterator = xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>;
    using const_iterator = const xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>;
    using reverse_iterator = std::reverse_iterator<xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>>;
    using const_reverse_iterator = const std::reverse_iterator<xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>>;
    
    
    template <xtd::size count = 0>
    constexpr span() : data_ {xtd::null}, length_ {0} {}
    
    template<class iterator_t>
    constexpr span(iterator_t first, iterator_t last) : data_ {&(*first)}, length_ {extent != dynamic_extent ? extent : static_cast<size_type>(std::distance(first, last))} {}
    /* Conflict with span(collection_t& items, xtd::size count)
    template<class iterator_t>
    span(iterator_t first, xtd::size count) : data_ {&(*first)}, length_ {extent != dynamic_extent ? extent : count} {}
     */
#if defined(__xtd__cpp_lib_type_identity)
    template<xtd::size len>
    constexpr span(std::type_identity_t<element_type> (&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
#else
    template<xtd::size len>
    constexpr span(element_type (&array)[len]) noexcept : data_ {const_cast<element_type*>(array)}, length_ {extent != dynamic_extent ? extent : len} {}
#endif
    template<class array_type_t, xtd::size len>
    constexpr span(const std::array<array_type_t, len>& array) noexcept : data_ {array.data()}, length_ {extent != dynamic_extent ? extent : len} {}
    template<class array_type_t, xtd::size len>
    constexpr span(std::array<array_type_t, len>& array) noexcept : data_ {array.data()}, length_ {extent != dynamic_extent ? extent : len} {}
#if defined(__xtd__cpp_lib_ranges)
    template<class range_t>
    constexpr span(range_t&& range) noexcept : data_ {xtd::ranges::data(range)}, length_ {extent != dynamic_extent ? extent : xtd::ranges::size(range)} {}
#else
    template<class 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<class collection_t>
    constexpr span(collection_t& items) noexcept : span {items, size_type {0}, items.size()} {}
     */
    template<class collection_t>
    constexpr span(collection_t& items, size_type length) : span {items, size_type {0}, length} {}
    template<class collection_t>
    constexpr span(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 span(type_t* const 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);
    }
 
    constexpr span(span&& items) = default;
    constexpr span(const span& items) = default;
    
    span& operator =(span&& items) = default;
    span& operator =(const span& items) = default;
    
    
    const_reference back() const {
      if (empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return *(data_ + length_ - 1);
    }
    
    const_iterator begin() const {return cbegin();}
    iterator begin() {return iterator {data_};}
    
    const_iterator cbegin() const {return const_iterator {data_};}
    const_iterator cend() const {return const_iterator {data_ + length_};}
    
    const_reverse_iterator crbegin() const {return const_reverse_iterator {iterator {data_ + length_}};}
    const_reverse_iterator crend() const {return const_reverse_iterator {iterator {data_}};}
    
    constexpr const_pointer data() const noexcept {return data_;}
    
    constexpr bool empty() const noexcept {return is_empty();}
    
    static const span empty_span;
    
    const_iterator end() const {return cend();}
    iterator end() {return iterator {data_ + length_};}
    
    const_reference front() const {
      if (empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return *data_;
    }
    
    constexpr bool is_empty() const noexcept {return !length_;}
 
    constexpr size_type length() const noexcept {return length_;}
 
    const_reverse_iterator rbegin() const {return crbegin();}
    reverse_iterator rbegin() {return reverse_iterator {iterator {data_ + length_}};}
    
    const_reverse_iterator rend() const {return crend();}
    reverse_iterator rend() {return reverse_iterator {iterator {data_}};}
    
    constexpr size_type size() const noexcept {return length();}
    
    constexpr size_type size_bytes() const noexcept {return length_ * sizeof(value_type);}
    
    
    const_reference at(size_type pos) const {
      if (pos >= length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return *(data_ + pos);
    }
    reference at(size_type pos) {
      if (pos >= length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return *(data_ + pos);
    }
    
    void clear() noexcept {
      for (auto& item : *this)
        item = value_type {};
    }
    
    template<xtd::size length>
    void copy_to(span<type_t, length>& destination) const {
      if (!try_copy_to(destination))
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
    }
 
    bool equals(const object& obj) const noexcept override {return is<span<value_type>>(obj) && equals(static_cast<const span<value_type>&>(obj));}
    bool equals(const span& rhs) const noexcept override {return length() == rhs.length() && data() == rhs.data();}
    
    void fill(const type_t& value) {
      for (auto& item : *this)
        item = value;
    }
    
    template<xtd::size count>
    span<type_t, count> first() const {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t, count> {data_, count};
    }
    span<type_t> first(xtd::size count) const {
      if (count > length_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return span<type_t> {data_, count};
    }
    
    xtd::size get_hash_code() const noexcept override {
      auto result = hash_code {};
      for (const auto& item : *this)
        result.add(item);
      return result.to_hash_code();
    }
 
    template<xtd::size count>
    span<type_t, count> last() const {
      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};
    }
    span<type_t> last(xtd::size count) const {
      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::size start, size_type lenght = xtd::dynamic_extent>
    span<type_t> slice() const {
      return lenght == xtd::dynamic_extent ? slice(start) : slice(start, lenght);
    }
 
    span<type_t> slice(size_type start) const {
      return slice(start, length_ - start);
    }
    
    span<type_t> slice(size_type start, size_type length) const {
      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::size offset, size_type count = xtd::dynamic_extent>
    span<type_t> subspan() const {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    span<type_t> subspan(size_type offset, size_type count = xtd::dynamic_extent) const {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    xtd::array<value_type> to_array() const noexcept {
      return data_ && length_ ? xtd::array<value_type>(data_, length_) : xtd::array<value_type> {};
    }
    
    string to_string() const noexcept override {
      if (typeof_<type_t>() == typeof_<char>()) return xtd::string::join("", *this);
      return xtd::string::format("[{}]", xtd::string::join(", ", *this));
    }
    
    template<xtd::size length>
    bool try_copy_to(span<type_t, length>& destination) const noexcept {
      if (destination.length() < this->length()) return false;
      for (auto index = xtd::size {}; index < length_; ++index)
        destination.at(index) = at(index);
      return true;
    }
    
    
    const_reference operator[](size_type index) const {return at(index);}
    reference operator[](size_type index) {return at(index);}
 
  private:
    pointer data_ = null;
    size_type length_ = size_type {};
  };
  
  template<class type_t, xtd::size extent>
  inline const span<type_t, extent> span<type_t, extent>::empty_span;
  
  // C++17 deduction guides for xtd::span
  // {
  template<class iterator_t>
  span(iterator_t, iterator_t) -> span<typename iterator_t::value_type>;
 
  template<class type_t, xtd::size len>
  span(type_t (&)[len]) noexcept -> span<type_t>;
  
  template< class type_t, xtd::size len>
  span(const std::array<type_t, len>&) noexcept -> span<const type_t>;
  
  template< class type_t, xtd::size len>
  span(std::array<type_t, len>&) noexcept -> span<type_t>;
 
#if defined(__xtd__cpp_lib_ranges)
  template<class range_t>
  span(range_t&&) noexcept -> span<std::remove_reference_t<xtd::ranges::range_reference_t<range_t>>>;
#else
  template<class range_t>
  span(range_t&&) noexcept -> span<std::remove_reference_t<typename range_t::value_type>>;
#endif
 
  template<class type_t>
  span(std::initializer_list<type_t>) noexcept -> span<const type_t>;
 
  template<class collection_t>
  span(const collection_t& items) noexcept -> span<const typename collection_t::value_type>;
  
  template<class collection_t>
  span(const collection_t&, xtd::size) -> span<const typename collection_t::value_type>;
 
  template<class collection_t>
  span(collection_t&, xtd::size) -> span<typename collection_t::value_type>;
  
  template<class collection_t>
  span(const collection_t&, xtd::size, xtd::size) -> span<const typename collection_t::value_type>;
 
  template<class collection_t>
  span(collection_t&, xtd::size, xtd::size) -> span<typename collection_t::value_type>;
  
  template<class type_t>
  span(type_t* const, xtd::size) -> span<type_t>;
  // }
}