Allow polymorphism with fine::ResourcePtr

This feature should introduce no breaking change to the existing API,
while allowing resources to be subclasses and behave as such.

This requires a change to how `ResourceWrapper` works, but since it is
an implementation detail, this should not be obvious to users of the
library, causing no expected breaking changes.

The biggest downside of this feature is a slight increase in unused
padding inside the `ResourceWrapper` class. With our now approach, we
now add on average `alignof(std::max_align_t) - alignof(T)` unused
bytes per resource.

Author: brodeuralexis

README.md

@@ -285,6 +285,32 @@ class Generator {
 If defined, the `destructor` callback is called first, and then the
 `T` destructor is called as usual.
 
+To make use of polymorphism with resources, only the base class must be
+declared using `FINE_RESOURCE`.  To construct derived classes, use the
+`fine::make_resource<Base, Derived>(...)` function:
+
+```c++
+class Supplier {
+public:
+    virtual ~Supplier() noexcept = default;
+
+    virtual std::int64_t supply() = 0;
+};
+FINE_RESOURCE(Supplier);
+
+class ConstantSupplier final : public Supplier {
+public:
+    ConstantSupplier(std::int64_t constant) : m_constant(constant) {}
+
+    std::int64_t supply() { return m_constant; }
+
+private:
+    std::int64_t m_constant;
+};
+
+fine::ResourcePtr<Supplier> supplier = fine::make_resource<Supplier, ConstantSupplier>(INT64_C(42));
+```
+
 Oftentimes NIFs deal with classes from third-party packages, in which
 case, you may not control how the objects are created and you cannot
 add callbacks such as `destructor` to the implementation. If you run

include/fine.hpp

@@ -15,6 +15,8 @@
 #include <variant>
 #include <vector>
 
+#include <iostream>
+
 #include <erl_nif.h>
 
 #if defined(_MSVC_LANG)
@@ -164,17 +166,32 @@ template <typename... Args> class Error {
 
 namespace __private__ {
 template <typename T> struct ResourceWrapper {
-  T resource;
-  bool initialized;
+  enum { INITIALIZED = 0 };
+
+  union {
+    struct {
+      bool initialized;
+    };
+    std::max_align_t _unused;
+  };
+
+  const T *resource() const { return reinterpret_cast<const T *>(this + 1); }
+
+  T *resource() noexcept { return reinterpret_cast<T *>(this + 1); }
+
+  template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
+  static constexpr std::size_t byte_size() noexcept {
+    return sizeof(ResourceWrapper) + sizeof(U);
+  }
 
   static void dtor(ErlNifEnv *env, void *ptr) {
     auto resource_wrapper = reinterpret_cast<ResourceWrapper<T> *>(ptr);
 
     if (resource_wrapper->initialized) {
       if constexpr (has_destructor<T>::value) {
-        resource_wrapper->resource.destructor(env);
+        resource_wrapper->resource()->destructor(env);
       }
-      resource_wrapper->resource.~T();
+      resource_wrapper->resource()->~T();
     }
   }
 
@@ -221,11 +238,11 @@ template <typename T> class ResourcePtr {
     return *this;
   }
 
-  T &operator*() const { return this->ptr->resource; }
+  T &operator*() const { return *this->ptr->resource(); }
 
-  T *operator->() const { return &this->ptr->resource; }
+  T *operator->() const { return this->ptr->resource(); }
 
-  T *get() const { return &this->ptr->resource; }
+  T *get() const { return this->ptr->resource(); }
 
   friend void swap(ResourcePtr<T> &left, ResourcePtr<T> &right) {
     using std::swap;
@@ -241,12 +258,17 @@ template <typename T> class ResourcePtr {
   // Friend functions that use the resource_type static member or the
   // private constructor.
 
-  template <typename U, typename... Args>
+  template <typename U, typename V, typename... Args, typename>
   friend ResourcePtr<U> make_resource(Args &&...args);
 
+  template <typename U>
+  friend Term make_resource_binary(ErlNifEnv *env, ResourcePtr<U> resource,
+                                   const char *data, size_t size);
+
   friend class Registration;
 
   friend struct Decoder<ResourcePtr<T>>;
+  friend struct Encoder<ResourcePtr<T>>;
 
   inline static ErlNifResourceType *resource_type = nullptr;
 
@@ -255,7 +277,8 @@ template <typename T> class ResourcePtr {
 
 // Allocates a new resource object, invoking its constructor with the
 // given arguments.
-template <typename T, typename... Args>
+template <typename T, typename U = T, typename... Args,
+          typename = std::enable_if_t<std::is_base_of_v<T, U>>>
 ResourcePtr<T> make_resource(Args &&...args) {
   auto type = ResourcePtr<T>::resource_type;
 
@@ -265,10 +288,10 @@ ResourcePtr<T> make_resource(Args &&...args) {
         " to register your resource type with the FINE_RESOURCE macro");
   }
 
-  void *allocation_ptr =
-      enif_alloc_resource(type, sizeof(__private__::ResourceWrapper<T>));
+  void *allocation_ptr = enif_alloc_resource(
+      type, __private__::ResourceWrapper<T>::template byte_size<U>());
 
-  auto resource_wrapper =
+  auto *resource_wrapper =
       reinterpret_cast<__private__::ResourceWrapper<T> *>(allocation_ptr);
 
   // We create ResourcePtr right away, to make sure the resource is
@@ -282,7 +305,8 @@ ResourcePtr<T> make_resource(Args &&...args) {
 
   // Invoke the constructor with prefect forwarding to initialize the
   // object at the VM-allocated memory
-  new (&resource_wrapper->resource) T(std::forward<Args>(args)...);
+  new (reinterpret_cast<U *>(resource_wrapper->resource()))
+      U(std::forward<Args>(args)...);
 
   resource_wrapper->initialized = true;
 
@@ -296,8 +320,8 @@ ResourcePtr<T> make_resource(Args &&...args) {
 template <typename T>
 Term make_resource_binary(ErlNifEnv *env, ResourcePtr<T> resource,
                           const char *data, size_t size) {
-  return enif_make_resource_binary(
-      env, reinterpret_cast<void *>(resource.get()), data, size);
+  return enif_make_resource_binary(env, reinterpret_cast<void *>(resource.ptr),
+                                   data, size);
 }
 
 // Creates a binary term copying data from the given buffer.
@@ -811,7 +835,7 @@ template <typename K, typename V> struct Encoder<std::map<K, V>> {
 
 template <typename T> struct Encoder<ResourcePtr<T>> {
   static ERL_NIF_TERM encode(ErlNifEnv *env, const ResourcePtr<T> &resource) {
-    return enif_make_resource(env, reinterpret_cast<void *>(resource.get()));
+    return enif_make_resource(env, reinterpret_cast<void *>(resource.ptr));
   }
 };
 

test/c_src/finest.cpp

@@ -1,11 +1,12 @@
 #include <cstring>
-#include <erl_nif.h>
 #include <exception>
-#include <fine.hpp>
 #include <optional>
 #include <stdexcept>
 #include <thread>
 
+#include <erl_nif.h>
+#include <fine.hpp>
+
 namespace finest {
 
 namespace atoms {
@@ -74,6 +75,30 @@ struct ExError {
   static constexpr auto is_exception = true;
 };
 
+struct AbstractRes {
+  virtual ~AbstractRes() noexcept = default;
+};
+FINE_RESOURCE(AbstractRes);
+
+struct ConcreteRes : AbstractRes {
+  ErlNifPid pid;
+
+  ConcreteRes(ErlNifPid pid) : pid(pid) {}
+
+  ~ConcreteRes() noexcept override {
+    auto target_pid = this->pid;
+
+    auto thread = std::thread([target_pid] {
+      auto msg_env = enif_alloc_env();
+      auto msg = fine::encode(msg_env, atoms::destructor_default);
+      enif_send(NULL, &target_pid, msg_env, msg);
+      enif_free_env(msg_env);
+    });
+
+    thread.detach();
+  }
+};
+
 int64_t add(ErlNifEnv *, int64_t x, int64_t y) { return x + y; }
 FINE_NIF(add, 0);
 
@@ -194,6 +219,11 @@ fine::Term resource_binary(ErlNifEnv *env,
 }
 FINE_NIF(resource_binary, 0);
 
+fine::ResourcePtr<AbstractRes> resource_abstract(ErlNifEnv *, ErlNifPid pid) {
+  return fine::make_resource<AbstractRes, ConcreteRes>(pid);
+}
+FINE_NIF(resource_abstract, 0);
+
 fine::Term make_new_binary(ErlNifEnv *env) {
   const char *buffer = "hello world";
   size_t size = 11;

test/lib/finest/nif.ex

@@ -41,6 +41,7 @@ defmodule Finest.NIF do
   def resource_create(_pid), do: err!()
   def resource_get(_resource), do: err!()
   def resource_binary(_resource), do: err!()
+  def resource_abstract(_pid), do: err!()
 
   def make_new_binary(), do: err!()
 

test/test/finest_test.exs

@@ -252,6 +252,13 @@ defmodule FinestTest do
 
       assert_receive :destructor_default
     end
+
+    test "resource can be abstract" do
+      NIF.resource_abstract(self())
+      :erlang.garbage_collect(self())
+
+      assert_receive :destructor_default
+    end
   end
 
   describe "make_new_binary" do