MemSpan.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Verizon Media 2020
 
#pragma once
 
#include "swoc/swoc_version.h"
#include "swoc/Scalar.h"
 
#include <cstring>
#include <memory>
#include <type_traits>
#include <ratio>
#include <tuple>
#include <exception>

#include <array>
#include <vector>
#include <string_view>
 
namespace swoc { inline namespace SWOC_VERSION_NS {
template <typename T> class MemSpan {
  using self_type = MemSpan; 
 
protected:
  T *_ptr       = nullptr; 
  size_t _count = 0;       
 
public:
  using value_type     = T;         
  using iterator       = T *;       
  using const_iterator = T const *; 

  constexpr MemSpan() = default;

  constexpr MemSpan(self_type const &that) = default;
  constexpr MemSpan(self_type &that) = default;

  constexpr MemSpan(value_type *ptr, size_t count);

  constexpr MemSpan(value_type *begin, value_type *end);

  template <auto N> constexpr MemSpan(T (&a)[N]);

  template <auto N, typename U,
            typename META =
              std::enable_if_t<std::conjunction_v<std::is_const<T>, std::is_same<std::remove_const_t<U>, std::remove_const_t<T>>>>>
  constexpr MemSpan(std::array<U, N> const &a);

  template <auto N> constexpr MemSpan(std::array<T, N> &a);

  template <typename U,
            typename META = std::enable_if_t<std::conjunction_v<std::is_const<T>, std::is_same<U, std::remove_const_t<T>>>>>
  constexpr MemSpan(MemSpan<U> const &that) : _ptr(that.data()), _count(that.count()) {}

  template <typename C, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<C>().data()), T *> &&
                                                      std::is_convertible_v<decltype(std::declval<C>().size()), size_t>,
                                                    void>>
  constexpr MemSpan(C &c);

  template <typename C, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<C>().data()), T *> &&
                                                      std::is_convertible_v<decltype(std::declval<C>().size()), size_t>,
                                                    void>>
  constexpr MemSpan(C const &c);

  constexpr MemSpan(std::nullptr_t);

  constexpr bool operator==(self_type const &that) const;

  bool is_same(self_type const &that) const;

  constexpr bool operator!=(self_type const &that) const;

  self_type &operator=(self_type const &that) = default;

  T &operator[](size_t idx) const;

  bool operator!() const;

  explicit operator bool() const;

  constexpr bool empty() const;



  constexpr T *begin() const;

  constexpr T *end() const;

  constexpr size_t size() const;

  constexpr size_t count() const;

  constexpr size_t length() const;

  constexpr size_t data_size() const;

  T *data() const;

  constexpr T *data_end() const;

  T &front();

  T &back();

  template <typename F> self_type &apply(F &&f);

  template <typename U = std::conditional_t<std::is_const_v<T>, void const, void>> MemSpan<U> rebind() const;

  self_type &assign(T *ptr,      
                    size_t count 
  );

  self_type &assign(T *first, T const *last);

  self_type &clear();

  bool contains(value_type const *p) const;

  constexpr self_type prefix(size_t count) const;

  constexpr self_type first(size_t count) const;

  self_type &remove_prefix(size_t count);

  self_type clip_prefix(size_t count);

  constexpr self_type suffix(size_t count) const;

  constexpr self_type last(size_t count) const;

  self_type &remove_suffix(size_t count);

  self_type clip_suffix(size_t count);

  constexpr self_type subspan(size_t offset, size_t count) const;

  constexpr self_type &restrict(size_t n);

  template <typename... Args> self_type &make(Args &&...args);

  void destroy();
 
  template <typename U> friend class MemSpan;
};

template <> class MemSpan<void const> {
  using self_type = MemSpan; 
  template <typename U> friend class MemSpan;
 
public:
  using value_type = void const; 
 
protected:
  void *_ptr   = nullptr; 
  size_t _size = 0;       
 
public:
  constexpr MemSpan() = default;

  constexpr MemSpan(self_type const &that) = default;

  constexpr self_type &operator=(self_type const &that) = default;

  template <auto N, typename U> constexpr MemSpan(U (&a)[N]);

  constexpr MemSpan(MemSpan<void> const &that);

  template <typename U> constexpr MemSpan(MemSpan<U> const &that);

  constexpr MemSpan(value_type *ptr, size_t n);

  MemSpan(value_type *begin, value_type *end);

  template <typename C, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<C>().size()), size_t>, void>>
  constexpr MemSpan(C const &c);

  constexpr MemSpan(std::nullptr_t);

  bool operator==(self_type const &that) const;

  bool is_same(self_type const &that) const;

  bool operator!=(self_type const &that) const;

  explicit operator bool() const;

  bool operator!() const;

  constexpr bool empty() const;

  constexpr size_t size() const;

  constexpr size_t count() const;

  constexpr size_t length() const;

  constexpr size_t data_size() const;

  constexpr value_type *data() const;

  value_type *data_end() const;

  constexpr self_type &operator=(MemSpan<void> const &that);

  template <typename U> self_type &operator=(MemSpan<U> const &that);

  self_type &assign(value_type *ptr, size_t n);

  self_type &assign(value_type *first, value_type const *last);

  template <typename U> MemSpan<U> rebind() const;

  template <typename U> U const *as_ptr() const;

  self_type &clear();

  bool contains(void const *ptr) const;

  self_type prefix(size_t n) const;

  self_type &remove_prefix(size_t n);

  self_type clip_prefix(size_t n);

  self_type suffix(size_t n) const;

  self_type &remove_suffix(size_t n);

  self_type clip_suffix(size_t n);

  constexpr self_type subspan(size_t offset, size_t n) const;

  template <typename T> self_type align() const;

  self_type align(size_t alignment) const;

  self_type align(size_t alignment, size_t obj_size) const;
};
 
template <> class MemSpan<void> : public MemSpan<void const> {
  using self_type  = MemSpan;
  using super_type = MemSpan<void const>;
  template <typename U> friend class MemSpan;
 
public:
  using value_type   = void;
  using pointer_type = value_type *;

  constexpr MemSpan() = default;

  constexpr MemSpan(self_type const &that) = default;

  constexpr self_type &operator=(self_type const &that) = default;

  template <typename U> constexpr MemSpan(MemSpan<U> const &that);

  constexpr MemSpan(value_type *start, size_t n);

  MemSpan(value_type *begin, value_type *end);

  template <auto N, typename U> constexpr MemSpan(U (&a)[N]);

  constexpr MemSpan(std::nullptr_t);

  constexpr value_type *data() const;

  value_type *data_end() const;

  template <typename U> self_type &operator=(MemSpan<U> const &that);

  template <typename C, typename = std::enable_if_t<!std::is_const_v<decltype(std::declval<C>().data()[0])> &&
                                                      std::is_convertible_v<decltype(std::declval<C>().size()), size_t>,
                                                    void>>
  constexpr MemSpan(C const &c);

  self_type &assign(value_type *ptr, size_t n);

  self_type &assign(value_type *first, value_type const *last);

  self_type prefix(size_t n) const;

  self_type &remove_prefix(size_t count);

  self_type clip_prefix(size_t n);

  self_type suffix(size_t n) const;

  self_type &remove_suffix(size_t n);

  self_type clip_suffix(size_t n);

  constexpr self_type subspan(size_t offset, size_t n) const;

  template <typename T> self_type align() const;

  self_type align(size_t alignment) const;

  self_type align(size_t alignment, size_t obj_size) const;

  template <typename U> MemSpan<U> rebind() const;

  template <typename U> U *as_ptr() const;

  self_type &clear();
 
protected:
  MemSpan(super_type const &super) : super_type(super) {}
};
 
// -- Implementation --
 
namespace detail {
inline size_t
ptr_distance(void const *first, void const *last) {
  return static_cast<const char *>(last) - static_cast<const char *>(first);
}
 
template <typename T>
size_t
ptr_distance(T const *first, T const *last) {
  return last - first;
}
 
inline void *
ptr_add(void *ptr, size_t count) {
  return static_cast<char *>(ptr) + count;
}
 
inline void const *
ptr_add(void const *ptr, size_t count) {
  return static_cast<char const *>(ptr) + count;
}


template <typename T, typename U> struct is_span_compatible {
  static constexpr bool value = (std::ratio<sizeof(T), sizeof(U)>::num == 1 || std::ratio<sizeof(U), sizeof(T)>::num == 1) &&
                                (std::is_const_v<U> || !std::is_const_v<T>); // can't lose constancy.
  static size_t count(size_t size);
};
 
template <typename T, typename U>
size_t
is_span_compatible<T, U>::count(size_t size) {
  if (size % sizeof(U)) {
    throw std::invalid_argument("MemSpan rebind where span size is not a multiple of the element size");
  }
  return size / sizeof(U);
}

// Must specialize for rebinding to @c void because @c sizeof doesn't work. Rebinding from @c void
// is handled by the @c MemSpan<void>::rebind specialization and doesn't use this mechanism.
template <typename T> struct is_span_compatible<T, void> {
  static constexpr bool value = !std::is_const_v<T>;
  static size_t count(size_t size);
};
 
template <typename T>
size_t
is_span_compatible<T, void>::count(size_t size) {
  return sizeof(T) * size;
}
 
template <typename T> struct is_span_compatible<T, void const> {
  static constexpr bool value = true;
  static size_t count(size_t size);
};
 
template <typename T>
size_t
is_span_compatible<T, void const>::count(size_t size) {
  return sizeof(T) * size;
}
 
} // namespace detail
 
// --- Standard memory operations ---
template class MemSpan<unsigned char>;
 
template <typename T>
int
memcmp(MemSpan<T> const &lhs, MemSpan<T> const &rhs) {
  int zret = 0;
  size_t n = lhs.size();
 
  // Seems a bit ugly but size comparisons must be done anyway to get the memcmp args.
  if (lhs.count() < rhs.count()) {
    zret = 1;
  } else if (lhs.count() > rhs.count()) {
    zret = -1;
    n    = rhs.size();
  }
  // else the counts are equal therefore @a n and @a zret are already correct.
 
  int r = std::memcmp(lhs.data(), rhs.data(), n);
  if (0 != r) { // If we got a not-equal, override the size based result.
    zret = r;
  }
 
  return zret;
}
 
using std::memcmp;
 
template <typename T>
T *
memcpy(MemSpan<T> &dst, MemSpan<T> const &src) {
  return static_cast<T *>(std::memcpy(dst.data(), src.data(), std::min(dst.size(), src.size())));
}
 
template <typename T>
T *
memcpy(MemSpan<T> &dst, T *src) {
  return static_cast<T *>(std::memcpy(dst.data(), src, dst.size()));
}
 
template <typename T>
T *
memcpy(T *dst, MemSpan<T> &src) {
  return static_cast<T *>(std::memcpy(dst, src.data(), src.size()));
}
 
inline char *
memcpy(MemSpan<char> &span, std::string_view view) {
  return static_cast<char *>(std::memcpy(span.data(), view.data(), std::min(view.size(), view.size())));
}
 
inline void *
memcpy(MemSpan<void> &span, std::string_view view) {
  return std::memcpy(span.data(), view.data(), std::min(view.size(), view.size()));
}
 
using std::memcpy;

template <typename T>
inline MemSpan<T> const &
memset(MemSpan<T> const &dst, T const &value) {
  for (auto &e : dst) {
    e = value;
  }
  return dst;
}


template <typename D, typename S>
auto
memset(MemSpan<D> const &dst, S c)
  -> std::enable_if_t<sizeof(D) == 1 && sizeof(S) == 1 && std::is_convertible_v<S, D>, MemSpan<D>> {
  D d = c;
  std::memset(dst.data(), d, dst.size());
  return dst;
}
 
// Optimization for @c char.
inline MemSpan<void> const &
memset(MemSpan<void> const &dst, char c) {
  std::memset(dst.data(), c, dst.size());
  return dst;
}

 
using std::memset;
 
// --- MemSpan<T> ---
 
template <typename T> constexpr MemSpan<T>::MemSpan(T *ptr, size_t count) : _ptr{ptr}, _count{count} {}
 
template <typename T> constexpr MemSpan<T>::MemSpan(T *begin, T *end) : _ptr{begin}, _count{detail::ptr_distance(begin, end)} {}
 
template <typename T> template <auto N> constexpr MemSpan<T>::MemSpan(T (&a)[N]) : _ptr{a}, _count{N} {
  // Magic for string literals to drop the trailing nul terminator, which is almost always what is expected.
  if constexpr (N > 0 && std::is_same_v<char const, T>) {
    if (a[N - 1] == 0) {
      _count -= 1;
    }
  }
}
 
template <typename T> constexpr MemSpan<T>::MemSpan(std::nullptr_t) {}
 
template <typename T>
template <auto N, typename U, typename META>
constexpr MemSpan<T>::MemSpan(std::array<U, N> const &a) : _ptr{a.data()}, _count{a.size()} {}
template <typename T> template <auto N> constexpr MemSpan<T>::MemSpan(std::array<T, N> &a) : _ptr{a.data()}, _count{a.size()} {}
template <typename T> template <typename C, typename> constexpr MemSpan<T>::MemSpan(C &c) : _ptr(c.data()), _count(c.size()) {}
template <typename T>
template <typename C, typename>
constexpr MemSpan<T>::MemSpan(C const &c) : _ptr(c.data()), _count(c.size()) {}
 
template <typename T>
MemSpan<T> &
MemSpan<T>::assign(T *ptr, size_t count) {
  _ptr   = ptr;
  _count = count;
  return *this;
}
 
template <typename T>
MemSpan<T> &
MemSpan<T>::assign(T *first, T const *last) {
  _ptr   = first;
  _count = detail::ptr_distance(first, last);
  return *this;
}
 
template <typename T>
MemSpan<T> &
MemSpan<T>::clear() {
  _ptr   = nullptr;
  _count = 0;
  return *this;
}
 
template <typename T>
bool
MemSpan<T>::is_same(self_type const &that) const {
  return _ptr == that._ptr && _count == that._count;
}
 
template <typename T>
constexpr bool
MemSpan<T>::operator==(self_type const &that) const {
  return _count == that._count && (_ptr == that._ptr || 0 == memcmp(_ptr, that._ptr, this->size()));
}
 
template <typename T>
constexpr bool
MemSpan<T>::operator!=(self_type const &that) const {
  return !(*this == that);
}
 
template <typename T>
bool
MemSpan<T>::operator!() const {
  return _count == 0;
}
 
template <typename T> MemSpan<T>::operator bool() const {
  return _count != 0;
}
 
template <typename T>
constexpr bool
MemSpan<T>::empty() const {
  return _count == 0;
}
 
template <typename T>
constexpr T *
MemSpan<T>::begin() const {
  return _ptr;
}
 
template <typename T>
T *
MemSpan<T>::data() const {
  return _ptr;
}
 
template <typename T>
constexpr T *
MemSpan<T>::data_end() const {
  return _ptr + _count;
}
 
template <typename T>
constexpr T *
MemSpan<T>::end() const {
  return _ptr + _count;
}
 
template <typename T>
T &
MemSpan<T>::operator[](size_t idx) const {
  return _ptr[idx];
}
 
template <typename T>
constexpr size_t
MemSpan<T>::size() const {
  return _count;
}
 
template <typename T>
constexpr size_t
MemSpan<T>::count() const {
  return _count;
}
 
template <typename T>
constexpr size_t
MemSpan<T>::length() const {
  return _count;
}
 
template <typename T>
constexpr size_t
MemSpan<T>::data_size() const {
  return _count * sizeof(T);
}
 
template <typename T>
bool
MemSpan<T>::contains(T const *ptr) const {
  return _ptr <= ptr && ptr < _ptr + _count;
}
 
template <typename T>
constexpr auto
MemSpan<T>::prefix(size_t count) const -> self_type {
  return {_ptr, std::min(count, _count)};
}
 
template <typename T>
constexpr auto
MemSpan<T>::first(size_t count) const -> self_type {
  return this->prefix(count);
}
 
template <typename T>
auto
MemSpan<T>::remove_prefix(size_t count) -> self_type & {
  count   = std::min(_count, count);
  _count -= count;
  _ptr   += count;
  return *this;
}
 
template <typename T>
constexpr auto
MemSpan<T>::suffix(size_t count) const -> self_type {
  count = std::min(_count, count);
  return {(_ptr + _count) - count, count};
}
 
template <typename T>
constexpr MemSpan<T>
MemSpan<T>::last(size_t count) const {
  return this->suffix(count);
}
 
template <typename T>
MemSpan<T> &
MemSpan<T>::remove_suffix(size_t count) {
  _count -= std::min(count, _count);
  return *this;
}
 
template <typename T>
auto
MemSpan<T>::clip_prefix(size_t count) -> self_type {
  if (count >= _count) {
    auto zret = *this;
    _count    = 0;
    return zret;
  }
  self_type zret{_ptr, count};
  _ptr   += count;
  _count -= count;
  return zret;
}
 
template <typename T>
auto
MemSpan<T>::clip_suffix(size_t count) -> self_type {
  if (count >= _count) {
    auto zret = *this;
    _count    = 0;
    return zret;
  }
  _count -= count;
  return {_ptr + _count, count};
}
 
template <typename T>
constexpr MemSpan<T>
MemSpan<T>::subspan(size_t offset, size_t count) const {
  return offset < _count ? self_type{this->data() + offset, std::min(count, _count - offset)} : self_type{};
}
 
template <typename T>
T &
MemSpan<T>::front() {
  return *_ptr;
}
 
template <typename T>
T &
MemSpan<T>::back() {
  return _ptr[_count - 1];
}
 
template <typename T>
template <typename F>
typename MemSpan<T>::self_type &
MemSpan<T>::apply(F &&f) {
  for (auto &item : *this) {
    f(item);
  }
  return *this;
}
 
template <typename T>
template <typename U>
MemSpan<U>
MemSpan<T>::rebind() const {
  static_assert(
    detail::is_span_compatible<T, U>::value,
    "MemSpan only allows rebinding between types where the sizes are such that one is an integral multiple of the other.");
  using VOID_PTR = std::conditional_t<std::is_const_v<U>, const void *, void *>;
  return {static_cast<U *>(static_cast<VOID_PTR>(_ptr)), detail::is_span_compatible<T, U>::count(this->data_size())};
}
 
template <typename T>
template <typename... Args>
auto
MemSpan<T>::make(Args &&...args) -> self_type & {
  for (T *elt = this->data(), *limit = this->data_end(); elt < limit; ++elt) {
    new (elt) T(std::forward<Args>(args)...);
  }
  return *this;
}
 
template <typename T>
void
MemSpan<T>::destroy() {
  for (T *elt = this->data(), *limit = this->data_end(); elt < limit; ++elt) {
    std::destroy_at(elt);
  }
}
 
// --- void specializations ---
 
template <typename U>
constexpr MemSpan<void const>::MemSpan(MemSpan<U> const &that)
  : _ptr(const_cast<std::remove_const_t<U> *>(that._ptr)), _size(sizeof(U) * that.size()) {}
template <typename U> constexpr MemSpan<void>::MemSpan(MemSpan<U> const &that) : super_type(that) {
  static_assert(!std::is_const_v<U>, "MemSpan<void> does not support constant memory.");
}
 
inline constexpr MemSpan<void const>::MemSpan(MemSpan<void> const &that) : _ptr(that._ptr), _size(that.size()) {}
 
inline constexpr MemSpan<void const>::MemSpan(value_type *ptr, size_t n) : _ptr{const_cast<void *>(ptr)}, _size{n} {}
inline constexpr MemSpan<void>::MemSpan(value_type *ptr, size_t n) : super_type(ptr, n) {}
 
inline MemSpan<void const>::MemSpan(value_type *begin, value_type *end)
  : _ptr{const_cast<void *>(begin)}, _size{detail::ptr_distance(begin, end)} {}
inline MemSpan<void>::MemSpan(value_type *begin, value_type *end) : super_type(begin, end) {}
 
template <auto N, typename U>
constexpr MemSpan<void const>::MemSpan(U (&a)[N]) : _ptr(const_cast<std::remove_const_t<U> *>(a)), _size(N * sizeof(U)) {
  // Magic for string literals to drop the trailing nul terminator, which is almost always what is expected.
  if constexpr (N > 0 && std::is_same_v<char const, U>) {
    if (a[N - 1] == 0) {
      _size -= 1;
    }
  }
}
template <auto N, typename U> constexpr MemSpan<void>::MemSpan(U (&a)[N]) : super_type(a) {
  static_assert(!std::is_const_v<U>, "Error: constructing non-constant view with constant data.");
}
 
template <typename C, typename>
constexpr MemSpan<void const>::MemSpan(C const &c)
  : _ptr(const_cast<std::remove_const_t<std::remove_reference_t<decltype(*(std::declval<C>().data()))>> *>(c.data())),
    _size(c.size() * sizeof(*(std::declval<C>().data()))) {}
template <typename C, typename> constexpr MemSpan<void>::MemSpan(C const &c) : super_type(c) {}
 
inline constexpr MemSpan<void const>::MemSpan(std::nullptr_t) {}
inline constexpr MemSpan<void>::MemSpan(std::nullptr_t) {}
 
inline bool
MemSpan<void const>::is_same(self_type const &that) const {
  return _ptr == that._ptr && _size == that._size;
}
 
inline bool
MemSpan<void const>::operator==(self_type const &that) const {
  return _size == that._size && (_ptr == that._ptr || 0 == memcmp(_ptr, that._ptr, _size));
}
 
inline bool
MemSpan<void const>::operator!=(self_type const &that) const {
  return !(*this == that);
}
 
inline MemSpan<void const>::operator bool() const {
  return _size != 0;
}
 
inline bool
MemSpan<void const>::operator!() const {
  return _size == 0;
}
 
inline constexpr bool
MemSpan<void const>::empty() const {
  return _size == 0;
}
 
template <typename U>
auto
MemSpan<void const>::operator=(MemSpan<U> const &that) -> self_type & {
  _ptr  = that._ptr;
  _size = sizeof(U) * that.size();
  return *this;
}
 
inline constexpr auto
MemSpan<void const>::operator=(MemSpan<void> const &that) -> self_type & {
  _ptr  = that._ptr;
  _size = that.size();
  return *this;
}
 
template <typename U>
auto
MemSpan<void>::operator=(MemSpan<U> const &that) -> self_type & {
  static_assert(!std::is_const_v<U>, "Cannot assign constant pointer to MemSpan<void>");
  this->super_type::operator=(that);
  return *this;
}
 
inline auto
MemSpan<void const>::assign(value_type *ptr, size_t n) -> self_type & {
  _ptr  = const_cast<void *>(ptr);
  _size = n;
  return *this;
}
 
inline auto
MemSpan<void>::assign(value_type *ptr, size_t n) -> self_type & {
  super_type::assign(ptr, n);
  return *this;
}
 
inline auto
MemSpan<void const>::assign(value_type *first, value_type const *last) -> self_type & {
  _ptr  = const_cast<void *>(first);
  _size = detail::ptr_distance(first, last);
  return *this;
}
 
inline auto
MemSpan<void>::assign(value_type *first, value_type const *last) -> self_type & {
  super_type::assign(first, last);
  return *this;
}
 
inline auto
MemSpan<void const>::clear() -> self_type & {
  _ptr  = nullptr;
  _size = 0;
  return *this;
}
 
inline auto
MemSpan<void>::clear() -> self_type & {
  super_type::clear();
  return *this;
}
 
inline constexpr void const *
MemSpan<void const>::data() const {
  return _ptr;
}
 
inline constexpr void *
MemSpan<void>::data() const {
  return _ptr;
}
 
inline void const *
MemSpan<void const>::data_end() const {
  return detail::ptr_add(_ptr, _size);
}
 
inline void *
MemSpan<void>::data_end() const {
  return detail::ptr_add(_ptr, _size);
}
 
inline constexpr size_t
MemSpan<void const>::size() const {
  return _size;
}
 
inline constexpr size_t
MemSpan<void const>::count() const {
  return _size;
}
 
inline constexpr size_t
MemSpan<void const>::length() const {
  return _size;
}
 
inline constexpr size_t
MemSpan<void const>::data_size() const {
  return _size;
}
 
inline bool
MemSpan<void const>::contains(value_type const *ptr) const {
  return _ptr <= ptr && ptr < this->data_end();
}
 
inline auto
MemSpan<void const>::prefix(size_t n) const -> self_type {
  return {_ptr, std::min(n, _size)};
}
 
inline auto
MemSpan<void>::prefix(size_t n) const -> self_type {
  return {_ptr, std::min(n, _size)};
}
 
inline auto
MemSpan<void const>::remove_prefix(size_t n) -> self_type & {
  n      = std::min(_size, n);
  _size -= n;
  _ptr   = detail::ptr_add(_ptr, n);
  return *this;
}
 
inline auto
MemSpan<void>::remove_prefix(size_t n) -> self_type & {
  super_type::remove_prefix(n);
  return *this;
}
 
inline auto
MemSpan<void const>::suffix(size_t n) const -> self_type {
  n = std::min(n, _size);
  return {detail::ptr_add(this->data_end(), -n), n};
}
 
inline auto
MemSpan<void>::suffix(size_t n) const -> self_type {
  n = std::min(n, _size);
  return {detail::ptr_add(this->data_end(), -n), n};
}
 
inline auto
MemSpan<void const>::remove_suffix(size_t n) -> self_type & {
  _size -= std::min(n, _size);
  return *this;
}
 
inline auto
MemSpan<void>::remove_suffix(size_t n) -> self_type & {
  this->super_type::remove_suffix(n);
  return *this;
}
 
inline auto
MemSpan<void const>::clip_prefix(size_t n) -> self_type {
  if (n >= _size) {
    auto zret = *this;
    _size     = 0;
    return zret;
  }
  self_type zret{_ptr, n};
  _ptr   = detail::ptr_add(_ptr, n);
  _size -= n;
  return zret;
}
 
inline auto
MemSpan<void>::clip_prefix(size_t n) -> self_type {
  return super_type::clip_prefix(n);
}
 
inline auto
MemSpan<void const>::clip_suffix(size_t n) -> self_type {
  if (n >= _size) {
    auto zret = *this;
    _size     = 0;
    return zret;
  }
  _size -= n;
  return {detail::ptr_add(_ptr, _size), n};
}
 
inline auto
MemSpan<void>::clip_suffix(size_t n) -> self_type {
  return super_type::clip_suffix(n);
}
 
inline constexpr auto
MemSpan<void const>::subspan(size_t offset, size_t n) const -> self_type {
  return offset <= _size ? self_type{detail::ptr_add(this->data(), offset), std::min(n, _size - offset)} : self_type{};
}
 
inline constexpr auto
MemSpan<void>::subspan(size_t offset, size_t n) const -> self_type {
  return offset <= _size ? self_type{detail::ptr_add(this->data(), offset), std::min(n, _size - offset)} : self_type{};
}
 
template <typename T> constexpr auto MemSpan<T>::restrict(size_t n) -> self_type & {
  _count = std::min(_count, n);
  return *this;
}
 
template <typename T>
auto
MemSpan<void const>::align() const -> self_type {
  return this->align(alignof(T), sizeof(T));
}
 
template <typename T>
auto
MemSpan<void>::align() const -> self_type {
  return this->align(alignof(T), sizeof(T));
}
 
inline auto
MemSpan<void const>::align(size_t alignment) const -> self_type {
  auto p       = uintptr_t(_ptr);
  auto padding = p & (alignment - 1);
  size_t size  = 0;
  if (_size > padding) { // if there's not enough to pad, result is zero size.
    size = _size - padding;
  }
  return {reinterpret_cast<void *>(p + padding), size};
}
 
inline auto
MemSpan<void>::align(size_t alignment) const -> self_type {
  auto &&[ptr, size] = super_type::align(alignment);
  return {ptr, size};
}
 
inline auto
MemSpan<void const>::align(size_t alignment, size_t obj_size) const -> self_type {
  auto p       = uintptr_t(_ptr);
  auto padding = p & (alignment - 1);
  size_t size  = 0;
  if (_size > padding) { // if there's not enough to pad, result is zero size.
    size = ((_size - padding) / obj_size) * obj_size;
  }
  return {reinterpret_cast<void *>(p + padding), size};
}
 
inline auto
MemSpan<void>::align(size_t alignment, size_t obj_size) const -> self_type {
  auto &&[ptr, n] = super_type::align(alignment, obj_size);
  return {ptr, n};
}
 
template <typename U>
MemSpan<U>
MemSpan<void const>::rebind() const {
  static_assert(std::is_const_v<U>, "Cannot rebind MemSpan<const void> to non-const type.");
  return {static_cast<U *>(_ptr), detail::is_span_compatible<value_type, U>::count(_size)};
}
 
template <typename U>
MemSpan<U>
MemSpan<void>::rebind() const {
  return {static_cast<U *>(_ptr), detail::is_span_compatible<value_type, U>::count(_size)};
}
 
// Specialize so that @c void -> @c void rebinding compiles and works as expected.
template <>
inline auto
MemSpan<void const>::rebind() const -> self_type {
  return *this;
}
 
template <>
inline auto
MemSpan<void>::rebind() const -> self_type {
  return *this;
}
 
template <>
inline auto
MemSpan<void>::rebind() const -> MemSpan<void const> {
  return {_ptr, _size};
}
 
template <typename U>
U *
MemSpan<void>::as_ptr() const {
  if (_size != sizeof(U)) {
    throw std::invalid_argument("MemSpan::as size is not compatible with target type.");
  }
  return static_cast<U *>(_ptr);
}
 
template <typename U>
U const *
MemSpan<void const>::as_ptr() const {
  if (_size != sizeof(U)) {
    throw std::invalid_argument("MemSpan::as size is not compatible with target type.");
  }
  return static_cast<U const *>(_ptr);
}

template <typename T, size_t N> MemSpan(std::array<T, N> &) -> MemSpan<T>;
template <typename T, size_t N> MemSpan(std::array<T, N> const &) -> MemSpan<T const>;
template <size_t N> MemSpan(char (&)[N]) -> MemSpan<char>;
template <size_t N> MemSpan(char const (&)[N]) -> MemSpan<char const>;
template <typename T> MemSpan(std::vector<T> &) -> MemSpan<T>;
template <typename T> MemSpan(std::vector<T> const &) -> MemSpan<T const>;
MemSpan(std::string_view const &) -> MemSpan<char const>;
MemSpan(std::string &) -> MemSpan<char>;
MemSpan(std::string const &) -> MemSpan<char const>;
 
namespace detail {
struct malloc_liberator {
  void
  operator()(void *ptr) {
    ::free(ptr);
  }
};
} // namespace detail.

template <typename T> using unique_malloc = std::unique_ptr<T, detail::malloc_liberator>;
}} // namespace swoc::SWOC_VERSION_NS

// STL tuple support - this allows the @c MemSpan to be used as a tuple of a pointer
// and size.
namespace std {
template <size_t IDX, typename R> class tuple_element<IDX, swoc::MemSpan<R>> {
  static_assert("swoc::MemSpan tuple index out of range");
};
 
template <typename R> class tuple_element<0, swoc::MemSpan<R>> {
public:
  using type = R *;
};
 
template <typename R> class tuple_element<1, swoc::MemSpan<R>> {
public:
  using type = size_t;
};
 
template <typename R> class tuple_size<swoc::MemSpan<R>> : public std::integral_constant<size_t, 2> {};
 
} // namespace std