Pointer.h

#pragma once
 
#ifdef __clang__
#pragma clang diagnostic push
// There is an static assert on that the Destructor type is trivially
// destructible, and thus there is no need to call the destructor,
// and we get by without a virtual destructor.
#pragma clang diagnostic ignored "-Wdelete-non-abstract-non-virtual-dtor"
#endif
 
#include <memory>
#include <new>
 
namespace Cogs
{
  struct DestructorBase
  {
    virtual void call(void *) {}
  };
 
  template<typename T, typename DeleterFunction>
  struct Destructor : public DestructorBase
  {
    static_assert(std::is_trivially_destructible<DeleterFunction>::value, "DeleterFunction must be trivially destructible.");
 
    Destructor(DeleterFunction t) : t(t) {}
 
    void call(void * ptr) override { t(static_cast<T *>(ptr)); }
 
  private:
    DeleterFunction t;
  };
 
  template<typename T>
  struct Pointer
  {
    Pointer() = default;
 
    template<typename DeleterFunction>
    Pointer(T * ptr, DeleterFunction deleter) : ptr(ptr)
    {
      static_assert(sizeof(Destructor<T, DeleterFunction>) <= sizeof(storage), "Deleter function too large (check capture list).");
      static_assert(std::is_trivially_destructible<Destructor<T, DeleterFunction>>::value, "Deleter must be trivially destructible.");
 
      new (storage) Destructor<T, DeleterFunction>(deleter);
    }
 
    Pointer(Pointer && other) noexcept
    {
      ptr = other.ptr;
      std::memcpy(storage, other.storage, sizeof(storage));
      other.ptr = nullptr;
    }
 
    Pointer & operator=(Pointer && other) noexcept
    {
      ptr = other.ptr;
      std::memcpy(storage, other.storage, sizeof(storage));
      other.ptr = nullptr;
 
      return *this;
    }
 
    Pointer(Pointer & other) = delete;
 
    Pointer & operator=(Pointer & other) = delete;
 
    ~Pointer()
    {
      if (ptr) {
        auto destructor = (DestructorBase *)storage;
        destructor->call(ptr);
        destructor->~DestructorBase();
      }
    }
 
    operator bool() const { return ptr != nullptr; }
 
    T * get() { return ptr; }
 
    const T * get() const { return ptr; }
 
    T * operator->() { return ptr; }
 
    const T * operator->() const { return ptr; }
 
  private:
    uint8_t storage[32 - sizeof(T *)] = {};
    T * ptr = nullptr;
  };
 
  static_assert(sizeof(Pointer<int>) == 32, "Internal size check failed.");
 
  template<typename T, typename DeleterFunction>
  Pointer<T> makePointer(T * t, DeleterFunction deleterFunc)
  {
    return Pointer<T>(t, deleterFunc);
  }
}
 
#ifdef __clang__
#pragma clang diagnostic pop
#endif