read_only_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 "span.hpp"
#include "typeof.hpp"
#include <type_traits>
#include <vector>
 
namespace xtd {
  template<class type_t, xtd::size extent = dynamic_extent>
  class read_only_span : public xtd::object, public xtd::iequatable<xtd::read_only_span<type_t, extent>> {
  public:
    
    using element_type = std::add_cv_t<type_t>;
    using value_type = std::add_cv_t<type_t>;
    using size_type = xtd::size;
    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&;
    using iterator = const xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>;
    using const_iterator = const xtd::collections::generic::helpers::wrap_pointer_iterator<pointer>;
    using reverse_iterator = const 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 read_only_span() : data_ {xtd::null}, length_ {0} {}
    
    template<class 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::size count)
    template<class iterator_t>
    read_only_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 read_only_span(const std::type_identity_t<element_type> (&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
#else
    template<xtd::size len>
    constexpr read_only_span(const element_type (&array)[len]) noexcept : data_ {array}, length_ {extent != dynamic_extent ? extent : len} {}
#endif
    template<class array_type_t, xtd::size len>
    constexpr read_only_span(const 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 read_only_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 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<class collection_t>
    constexpr read_only_span(collection_t& items) noexcept : span {items, size_type {0}, items.size()} {}
     */
    template<class collection_t>
    constexpr read_only_span(const collection_t& items, size_type length) : read_only_span {items, size_type {0}, length} {}
    template<class 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);
    }
 
    constexpr read_only_span(read_only_span&& items) = default;
    constexpr read_only_span(const read_only_span& items) = default;
    
    read_only_span& operator =(read_only_span&& items) = default;
    read_only_span& operator =(const read_only_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();}
    
    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 read_only_span empty_read_only_span;
    
    const_iterator end() const {return cend();}
    
    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();}
    
    const_reverse_iterator rend() const {return crend();}
    
    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);
    }
    
    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<read_only_span<value_type>>(obj) && equals(static_cast<const read_only_span<value_type>&>(obj));}
    bool equals(const read_only_span& rhs) const noexcept override {return length() == rhs.length() && data() == rhs.data();}
    
    template<xtd::size count>
    read_only_span<type_t, count> first() const {
      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};
    }
    read_only_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 read_only_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>
    read_only_span<type_t, count> last() const {
      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};
    }
    read_only_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 read_only_span<type_t> {data_ + length_ - count, count};
    }
 
    template<xtd::size start, size_type lenght = xtd::dynamic_extent>
    read_only_span<type_t> slice() const {
      return lenght == xtd::dynamic_extent ? slice(start) : slice(start, lenght);
    }
 
    read_only_span<type_t> slice(size_type start) const {
      return slice(start, length_ - start);
    }
    
    read_only_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 read_only_span<type_t> {data_ + start, length};
    }
 
    template<xtd::size offset, size_type count = xtd::dynamic_extent>
    read_only_span<type_t> subspan() const {
      return count == xtd::dynamic_extent ? slice(offset) : slice(offset, count);
    }
    
    read_only_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<std::remove_cv_t<type_t>> to_array() const noexcept {
      return data_ && length_ ? xtd::array<std::remove_cv_t<type_t>>(data_, length_) : xtd::array<std::remove_cv_t<type_t>> {};
    }
    
    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);}
 
  private:
    pointer data_ = null;
    size_type length_ = size_type {};
  };
  
  template<class type_t, xtd::size extent>
  inline const read_only_span<type_t, extent> read_only_span<type_t, extent>::empty_read_only_span;
  
  // C++17 deduction guides for xtd::read_only_span
  // {
  template<class iterator_t>
  read_only_span(iterator_t first, iterator_t last) -> read_only_span<typename iterator_t::value_type>;
  
  template<class type_t, xtd::size len>
  read_only_span(const type_t (&array)[len]) -> read_only_span<type_t>;
 
  template< class type_t, xtd::size len>
  read_only_span(const std::array<type_t, len>& array) -> read_only_span<type_t>;
 
#if defined(__xtd__cpp_lib_ranges)
  template<class range_t>
  read_only_span(range_t&& items) -> read_only_span<typename std::remove_reference_t<xtd::ranges::range_reference_t<range_t>>>;
#else
  template<class range_t>
  read_only_span(range_t&& items) -> read_only_span<typename range_t::value_type>;
#endif
 
  template<class collection_t>
  read_only_span(const collection_t& items) -> read_only_span<typename collection_t::value_type>;
  
  template<class collection_t>
  read_only_span(const collection_t& items, xtd::size) -> read_only_span<typename collection_t::value_type>;
  
  template<class collection_t>
  read_only_span(const collection_t& items, xtd::size, xtd::size) -> read_only_span<typename collection_t::value_type>;
 
  template<class type_t>
  read_only_span(const type_t* data, xtd::size size) -> read_only_span<type_t>;
  // }
}