SDL3pp_ownPtr.h

#ifndef SDL3PP_OWN_PTR_H_
#define SDL3PP_OWN_PTR_H_
 
#include <memory>
#include <span>
 
namespace SDL {
 
struct PtrDeleter
{
  void operator()(void* ptr) const;
};
 
template<class T>
using OwnPtr = std::unique_ptr<T, PtrDeleter>;
 
template<class T>
class OwnArray
{
  OwnPtr<T> m_ptr;
  size_t m_size = 0;
 
public:
  constexpr OwnArray(std::nullptr_t = nullptr) {}
 
  constexpr explicit OwnArray(T* ptr, size_t size)
    : m_ptr(ptr)
    , m_size(size)
  {
  }
 
  constexpr explicit OwnArray(T* ptr)
    : m_ptr(ptr)
  {
    if (ptr) {
      auto endPtr = ptr;
      while (*endPtr) ++endPtr;
      m_size = endPtr - ptr;
    }
  }
 
  constexpr explicit operator bool() const { return bool(m_ptr); }
 
  constexpr bool empty() const { return !m_ptr; }
 
  constexpr T* data() { return m_ptr.get(); }
 
  constexpr const T* data() const { return m_ptr.get(); }
 
  constexpr size_t size() const { return m_size; }
 
  T* release() { return m_ptr.release(); }
 
  void reset(T* newValue = nullptr)
  {
    m_ptr.reset(newValue);
    if (newValue) {
      auto endPtr = newValue;
      while (*endPtr) ++endPtr;
      m_size = endPtr - newValue;
    }
  }
 
  void reset(T* newValue, size_t size)
  {
    m_ptr.reset(newValue);
    m_size = size;
  }
 
  constexpr T& operator[](size_t i) { return m_ptr.get()[i]; }
 
  constexpr const T& operator[](size_t i) const { return m_ptr.get()[i]; }
 
  T* begin() { return data(); }
 
  const T* begin() const { return data(); }
 
  const T* cbegin() const { return begin(); }
 
  T* end() { return begin() + size(); }
 
  const T* end() const { return begin() + size(); }
 
  const T* cend() const { return begin() + size(); }
 
  T& front() { return *data(); }
 
  T& back() { return begin()[size()]; }
};
 
template<class T>
using RefArray = std::span<T>;
 
 
} // namespace SDL
#endif /* SDL3PP_OWN_PTR_H_ */