span.h

Go to the documentation of this file.

/* Diagnostic Client library
 * Copyright (C) 2024  Avijit Dey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_SPAN_H_
#define DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_SPAN_H_
 
#include <array>
#include <iostream>
#include <limits>
#include <type_traits>
#include <utility>
 
namespace core_type {
 
constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max();
 
template<typename T, std::size_t Extent = dynamic_extent>
class Span;
 
namespace details {
 
inline void CheckIfExpectedOrAbort(bool cond, const char *message, const std::string_view file_name,
                                   int line_no) {
  if (!cond) {
    std::cerr << message << " [" << file_name << ":" << line_no << "]" << std::endl;
    std::abort();
  }
}
 
template<typename T>
using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
template<typename>
struct is_span : std::false_type {};
 
template<typename T, std::size_t Extent>
struct is_span<Span<T, Extent>> : std::true_type {};
 
template<typename>
struct is_std_array : std::false_type {};
 
template<typename T, std::size_t N>
struct is_std_array<std::array<T, N>> : std::true_type {};
 
template<typename T, typename = void>
struct is_data_size_valid : std::false_type {};
 
template<typename T>
struct is_data_size_valid<
    T, std::void_t<decltype(std::data(std::declval<T>())), decltype(std::size(std::declval<T>()))>>
    : std::true_type {};
 
template<typename T, typename ElementType = remove_cv_ref_t<T>>
struct is_container_type {
  static constexpr bool value = !is_span<ElementType>::value && !is_std_array<ElementType>::value &&
                                !std::is_array<ElementType>::value && is_data_size_valid<T>::value;
};
 
template<typename, typename, typename = void>
struct is_container_element_type_convertible : std::false_type {};
 
template<typename F, typename T>
struct is_container_element_type_convertible<
    F, T,
    typename std::enable_if<std::is_convertible<
        std::remove_pointer_t<decltype(std::data(std::declval<F>()))> (*)[], T (*)[]>::value>::type>
    : std::true_type {};
 
template<typename T, std::size_t Extent>
struct span_storage {
  constexpr span_storage() noexcept = default;
 
  constexpr span_storage(T *ptr, std::size_t) noexcept : ptr_{ptr} {}
 
  T *ptr_ = nullptr;
  std::size_t size_{Extent};
};
 
template<typename T>
struct span_storage<T, dynamic_extent> {
  constexpr span_storage() noexcept = default;
 
  constexpr span_storage(T *ptr, std::size_t size) noexcept : ptr_{ptr}, size_{size} {}
 
  T *ptr_ = nullptr;
  std::size_t size_ = 0;
};
 
}  // namespace details
 
template<typename T, std::size_t Extent>
class Span final {
  static_assert(!std::is_abstract<T>::value,
                "A span's element type cannot be an abstract class type");
 
 public:
  using element_type = T;
 
  using value_type = typename std::remove_cv<element_type>::type;
 
  using size_type = std::size_t;
 
  using difference_type = std::ptrdiff_t;
 
  using pointer = element_type *;
 
  using const_pointer = const element_type *;
 
  using reference = element_type &;
 
  using const_reference = const element_type &;
 
  using iterator = pointer;
 
  using const_iterator = const_pointer;
 
  using reverse_iterator = std::reverse_iterator<iterator>;
 
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  static constexpr size_type extent = Extent;
 
  template<std::size_t E = Extent,
           typename std::enable_if<(E == dynamic_extent || E == 0), bool>::type = true>
  constexpr Span() noexcept {}
 
  constexpr Span(pointer ptr, size_type count) : storage_{ptr, count} {
    details::CheckIfExpectedOrAbort(Extent == dynamic_extent || count == Extent, "Invalid range",
                                    __FILE__, __LINE__);
  }
 
  constexpr Span(pointer first_elem, pointer last_elem)
      : storage_{first_elem, last_elem - first_elem} {
    details::CheckIfExpectedOrAbort(Extent == dynamic_extent || (last_elem - first_elem) == Extent,
                                    "Invalid range", __FILE__, __LINE__);
  }
 
  template<std::size_t N, std::size_t E = Extent,
           typename std::enable_if<
               (E == dynamic_extent || N == extent) &&
                   details::is_container_element_type_convertible<element_type (&)[N], T>::value,
               bool>::type = true>
  constexpr explicit Span(element_type (&arr)[N]) noexcept : storage_{arr, N} {}
 
  template<typename U, std::size_t N, std::size_t E = Extent,
           typename std::enable_if<
               (E == dynamic_extent || N == extent) &&
                   details::is_container_element_type_convertible<std::array<U, N> &, T>::value,
               bool>::type = true>
  constexpr explicit Span(std::array<U, N> &arr) noexcept : storage_{arr.data(), N} {}
 
  template<typename U, std::size_t N, std::size_t E = Extent,
           typename std::enable_if<(E == dynamic_extent || N == extent) &&
                                       details::is_container_element_type_convertible<
                                           const std::array<U, N> &, T>::value,
                                   bool>::type = true>
  constexpr explicit Span(const std::array<U, N> &arr) noexcept : storage_{arr.data(), N} {}
 
  template<typename Container, std::size_t E = Extent,
           typename std::enable_if<
               (E == dynamic_extent) && details::is_container_type<Container>::value &&
                   details::is_container_element_type_convertible<Container &, T>::value,
               bool>::type = true>
  constexpr explicit Span(Container &cont) noexcept : storage_{std::data(cont), std::size(cont)} {}
 
  template<typename Container, std::size_t E = Extent,
           typename std::enable_if<
               (E == dynamic_extent) && details::is_container_type<Container>::value &&
                   details::is_container_element_type_convertible<Container &, T>::value,
               bool>::type = true>
  constexpr explicit Span(const Container &cont) noexcept
      : storage_{std::data(cont), std::size(cont)} {}
 
  constexpr Span(const Span &) noexcept = default;
 
  template<
      typename U, std::size_t N,
      typename std::enable_if<
          (Extent == dynamic_extent || N == dynamic_extent || Extent == N) &&
          details::is_container_element_type_convertible<U (*)[], T (*)[]>::value>::type = true>
  constexpr explicit Span(const Span<U, N> &other_span) noexcept
      : storage_{other_span.data(), other_span.size()} {}
 
  ~Span() noexcept = default;
 
  constexpr Span &operator=(const Span &other) noexcept = default;
 
  template<std::size_t Count>
  constexpr Span<element_type, Count> first() const {
    details::CheckIfExpectedOrAbort(Count <= size(), "Count > size()", __FILE__, __LINE__);
    return Span{data(), Count};
  }
 
  constexpr Span<element_type, dynamic_extent> first(size_type count) const {
    details::CheckIfExpectedOrAbort(count <= size(), "Count > size()", __FILE__, __LINE__);
    return Span{data(), count};
  }
 
  template<std::size_t Count>
  constexpr Span<element_type, Count> last() const {
    details::CheckIfExpectedOrAbort(Count <= size(), "Count > size()", __FILE__, __LINE__);
    return Span{data() + (size() - Count), Count};
  }
 
  constexpr Span<element_type, dynamic_extent> last(size_type count) const {
    details::CheckIfExpectedOrAbort(count <= size(), "count > size()", __FILE__, __LINE__);
    return Span{data() + (size() - count), count};
  }
 
  template<std::size_t Offset, std::size_t Count = dynamic_extent>
  constexpr auto subspan() const noexcept
      -> Span<element_type, Count != dynamic_extent
                                ? Count
                                : (Extent != dynamic_extent ? Extent - Offset : dynamic_extent)> {
    details::CheckIfExpectedOrAbort(
        (Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)),
        "(Offset <= size() && (Count == dynamic_extent || Count <= size() - "
        "Offset))",
        __FILE__, __LINE__);
    return Span{data() + Offset, Count != dynamic_extent ? Count : size() - Offset};
  }
 
  constexpr Span<element_type, dynamic_extent> subspan(size_type offset,
                                                       size_type count = dynamic_extent) const {
    details::CheckIfExpectedOrAbort(
        (offset <= size() && (count == dynamic_extent || count <= size() - offset)),
        "(offset <= size() && (count == dynamic_extent || count <= size() - "
        "offset))",
        __FILE__, __LINE__);
    return {data() + offset, count == dynamic_extent ? size() - offset : count};
  }
 
  constexpr size_type size() const noexcept { return storage_.size_; }
 
  constexpr size_type size_bytes() const noexcept { return size() * sizeof(element_type); }
 
  constexpr bool empty() const noexcept { return size() == 0u; }
 
  constexpr reference operator[](size_type idx) const {
    details::CheckIfExpectedOrAbort(idx < size(), "idx > size()", __FILE__, __LINE__);
    return *(data() + idx);
  }
 
  constexpr reference front() const {
    details::CheckIfExpectedOrAbort(!empty(), "Span is empty", __FILE__, __LINE__);
    return *(data());
  }
 
  constexpr reference back() const {
    details::CheckIfExpectedOrAbort(!empty(), "Span is empty", __FILE__, __LINE__);
    return *(data() + (size() - 1));
  }
 
  constexpr pointer data() const noexcept { return storage_.ptr_; }
 
  constexpr iterator begin() const noexcept { return data(); }
 
  constexpr iterator end() const noexcept { return data() + size(); }
 
  constexpr const_iterator cbegin() const noexcept { return const_iterator(begin()); }
 
  constexpr const_iterator cend() const noexcept { return const_iterator(end()); }
 
  constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
 
  constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
 
  constexpr const_reverse_iterator crbegin() const noexcept {
    return const_reverse_iterator(end());
  }
 
  constexpr const_reverse_iterator crend() const noexcept {
    return const_reverse_iterator(begin());
  }
 
 private:
  details::span_storage<T, Extent> storage_;
};
 
template<class T, size_t N>
Span(T (&)[N]) -> Span<T, N>;
 
template<class T, size_t N>
Span(std::array<T, N> &) -> Span<T, N>;
 
template<class T, size_t N>
Span(const std::array<T, N> &) -> Span<const T, N>;
 
template<class Container>
Span(Container &) -> Span<
    typename std::remove_reference<decltype(*std::data(std::declval<Container &>()))>::type>;
 
template<class Container>
Span(const Container &) -> Span<const typename Container::value_type>;
 
}  // namespace core_type
 
#endif  // DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_SPAN_H_