span.h

Go to the documentation of this file.

#ifndef MILLICAST_API_SPAN_H
#define MILLICAST_API_SPAN_H
 
#ifdef __cplusplus
 
#include <cstddef>
#include <iterator>
 
#include "exports.h"
 
namespace millicast {
 
namespace detail {
 
template <typename T, typename E, typename = void>
// NOLINTNEXTLINE(readability-identifier-naming)
struct is_container_element_type_compatible : std::false_type {};
 
template <typename T, typename E>
struct is_container_element_type_compatible<
    T,
    E,
    typename std::enable_if<
        !std::is_same<typename std::remove_cv<decltype(std::data(
                          std::declval<T>()))>::type,
                      void>::value &&
        std::is_convertible<
            std::remove_pointer_t<decltype(std::declval<T>().data())> (*)[],
            E (*)[]>::value>::type> : std::true_type {};
}  // namespace detail
 
template <typename T>
class MILLICAST_TEMPLATE_API Span {
 public:
  using element_type = T;
  using pointer = element_type*;
  using reference = element_type&;
 
  constexpr Span() noexcept = default;
  constexpr Span(pointer ptr, size_t size) noexcept : _ptr(ptr), _size(size) {}
 
  template <size_t N>
  constexpr Span(T (&arr)[N]) noexcept : Span(arr, N) {}
  constexpr Span(const Span&) noexcept = default;
 
  template <
      typename C,
      typename std::enable_if<
          std::is_same_v<typename C::value_type, T> ||
              detail::is_container_element_type_compatible<const C&, T>::value,
          int>::type = 0>
  constexpr Span(const C& container) noexcept
      : _ptr(std::data(container)), _size(std::size(container)) {}
 
  template <typename C,
            typename std::enable_if<
                std::is_same_v<typename C::value_type, T> ||
                    detail::is_container_element_type_compatible<C&, T>::value,
                int>::type = 0>
  constexpr Span(C& container) noexcept
      : _ptr(std::data(container)), _size(std::size(container)) {}
 
  template <
      typename OtherElementType,
      typename std::enable_if<!std::is_same_v<OtherElementType, T> &&
                                  detail::is_container_element_type_compatible<
                                      const Span<OtherElementType>&,
                                      T>::value,
                              int>::type = 0>
  constexpr Span(const Span<OtherElementType>& other) noexcept
      : _ptr(other._ptr), _size(other._size) {}
 
  constexpr T* data() const { return _ptr; }
  constexpr T* begin() const { return data(); }
  constexpr T* end() const { return data() + size(); }
 
  [[nodiscard]] constexpr size_t size() const { return _size; }
  [[nodiscard]] constexpr size_t size_bytes() const {
    return size() * sizeof(T);
  }
  [[nodiscard]] constexpr bool empty() const { return size() == 0; }
 
 private:
  T* _ptr{nullptr};
  size_t _size{};
};
}  // namespace millicast
 
#endif // __cplusplus
#endif // MILLICAST_API_SPAN_H