react-native-nitro-modules 0.22.0 → 0.22.1

package/cpp/core/ArrayBuffer.cpp

@@ -6,7 +6,7 @@
 //
 
 #include "ArrayBuffer.hpp"
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <functional>
 #include <jsi/jsi.h>
 #include <thread>
@@ -61,7 +61,7 @@ bool NativeArrayBuffer::isOwner() const noexcept {
 
 // 3. JSArrayBuffer
 
-JSArrayBuffer::JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference)
+JSArrayBuffer::JSArrayBuffer(jsi::Runtime* runtime, BorrowingReference<jsi::ArrayBuffer> jsReference)
     : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference), _initialThreadId(std::this_thread::get_id()) {}
 
 JSArrayBuffer::~JSArrayBuffer() {}

package/cpp/core/ArrayBuffer.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <jsi/jsi.h>
 #include <thread>
 #include <vector>
@@ -122,7 +122,7 @@ private:
  */
 class JSArrayBuffer final : public ArrayBuffer {
 public:
-  explicit JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference);
+  explicit JSArrayBuffer(jsi::Runtime* runtime, BorrowingReference<jsi::ArrayBuffer> jsReference);
   ~JSArrayBuffer();
 
 public:
@@ -141,7 +141,7 @@ public:
 
 private:
   jsi::Runtime* _runtime;
-  OwningReference<jsi::ArrayBuffer> _jsReference;
+  BorrowingReference<jsi::ArrayBuffer> _jsReference;
   std::thread::id _initialThreadId;
 };
 

package/cpp/core/HybridObject.hpp

@@ -136,7 +136,7 @@ protected:
 private:
   static constexpr auto TAG = "HybridObject";
   const char* _name = TAG;
-  std::unordered_map<jsi::Runtime*, OwningReference<jsi::WeakObject>> _objectCache;
+  std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::WeakObject>> _objectCache;
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSICache.cpp

@@ -14,12 +14,12 @@ namespace margelo::nitro {
 static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
 
 template <typename T>
-inline void destroyReferences(const std::vector<BorrowingReference<T>>& references) {
+inline void destroyReferences(const std::vector<WeakReference<T>>& references) {
   for (auto& func : references) {
-    OwningReference<T> owning = func.lock();
-    if (owning) {
+    BorrowingReference<T> reference = func.lock();
+    if (reference) {
       // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
-      owning.destroy();
+      reference.destroy();
     }
   }
 }

package/cpp/jsi/JSICache.hpp

@@ -9,7 +9,7 @@
 
 #include "BorrowingReference.hpp"
 #include "NitroLogger.hpp"
-#include "OwningReference.hpp"
+#include "WeakReference.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <mutex>
@@ -24,12 +24,12 @@ class JSICacheReference;
 
 /**
  * A `JSICache` can safely store `jsi::Value` instances (e.g. `jsi::Object` or
- * `jsi::Function`) inside `OwningReference<T>`.
+ * `jsi::Function`) inside `BorrowingReference<T>`.
  *
  * `jsi::Value`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
  * is deleted - even if there are still strong references to the `jsi::Value`.
  *
- * To access a `OwningReference<jsi::Value>` safely, use `lock()` to get an `OwningLock<jsi::Value>`.
+ * To access a `BorrowingReference<jsi::Value>` safely, use `lock()` to get an `OwningLock<jsi::Value>`.
  * This will allow you to access the `jsi::Value` as long as the `OwningLock` is alive,
  * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
@@ -59,11 +59,11 @@ private:
 
 private:
   std::mutex _mutex;
-  std::vector<BorrowingReference<jsi::Value>> _valueCache;
-  std::vector<BorrowingReference<jsi::Object>> _objectCache;
-  std::vector<BorrowingReference<jsi::Function>> _functionCache;
-  std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
-  std::vector<BorrowingReference<jsi::ArrayBuffer>> _arrayBufferCache;
+  std::vector<WeakReference<jsi::Value>> _valueCache;
+  std::vector<WeakReference<jsi::Object>> _objectCache;
+  std::vector<WeakReference<jsi::Function>> _functionCache;
+  std::vector<WeakReference<jsi::WeakObject>> _weakObjectCache;
+  std::vector<WeakReference<jsi::ArrayBuffer>> _arrayBufferCache;
 
 private:
   static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
@@ -83,28 +83,28 @@ public:
   }
 
 public:
-  OwningReference<jsi::Value> makeShared(jsi::Value&& value) {
-    OwningReference<jsi::Value> owning(new jsi::Value(std::move(value)));
+  BorrowingReference<jsi::Value> makeShared(jsi::Value&& value) {
+    BorrowingReference<jsi::Value> owning(new jsi::Value(std::move(value)));
     _strongCache->_valueCache.push_back(owning.weak());
     return owning;
   }
-  OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
-    OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
+  BorrowingReference<jsi::Object> makeShared(jsi::Object&& value) {
+    BorrowingReference<jsi::Object> owning(new jsi::Object(std::move(value)));
     _strongCache->_objectCache.push_back(owning.weak());
     return owning;
   }
-  OwningReference<jsi::Function> makeShared(jsi::Function&& value) {
-    OwningReference<jsi::Function> owning(new jsi::Function(std::move(value)));
+  BorrowingReference<jsi::Function> makeShared(jsi::Function&& value) {
+    BorrowingReference<jsi::Function> owning(new jsi::Function(std::move(value)));
     _strongCache->_functionCache.push_back(owning.weak());
     return owning;
   }
-  OwningReference<jsi::WeakObject> makeShared(jsi::WeakObject&& value) {
-    OwningReference<jsi::WeakObject> owning(new jsi::WeakObject(std::move(value)));
+  BorrowingReference<jsi::WeakObject> makeShared(jsi::WeakObject&& value) {
+    BorrowingReference<jsi::WeakObject> owning(new jsi::WeakObject(std::move(value)));
     _strongCache->_weakObjectCache.push_back(owning.weak());
     return owning;
   }
-  OwningReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
-    OwningReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
+  BorrowingReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
+    BorrowingReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
     _strongCache->_arrayBufferCache.push_back(owning.weak());
     return owning;
   }

package/cpp/jsi/JSIConverter+Function.hpp

@@ -34,7 +34,7 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
     auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeShared(std::move(function));
+    BorrowingReference<jsi::Function> sharedFunction = cache.makeShared(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
@@ -94,7 +94,8 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
   }
 
 private:
-  static inline ResultingType callJSFunction(jsi::Runtime& runtime, const OwningReference<jsi::Function>& function, const Args&... args) {
+  static inline ResultingType callJSFunction(jsi::Runtime& runtime, const BorrowingReference<jsi::Function>& function,
+                                             const Args&... args) {
     if (!function) {
       if constexpr (std::is_void_v<ResultingType>) {
         // runtime has already been deleted. since this returns void, we can just ignore it being deleted.

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -26,7 +26,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   auto& prototypeCache = _prototypeCache[&runtime];
   auto cachedPrototype = prototypeCache.find(prototype->getNativeInstanceId());
   if (cachedPrototype != prototypeCache.end()) {
-    const OwningReference<jsi::Object>& cachedObject = cachedPrototype->second;
+    const BorrowingReference<jsi::Object>& cachedObject = cachedPrototype->second;
     return jsi::Value(runtime, *cachedObject).getObject(runtime);
   }
 
@@ -68,7 +68,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
 
   // 6. Throw it into our cache so the next lookup can be cached and therefore faster
   JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
-  OwningReference<jsi::Object> cachedObject = jsiCache.makeShared(std::move(object));
+  BorrowingReference<jsi::Object> cachedObject = jsiCache.makeShared(std::move(object));
   prototypeCache.emplace(prototype->getNativeInstanceId(), cachedObject);
 
   // 7. In DEBUG, add a __type info to the prototype object.

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -7,8 +7,8 @@
 
 #pragma once
 
+#include "BorrowingReference.hpp"
 #include "HybridFunction.hpp"
-#include "OwningReference.hpp"
 #include "Prototype.hpp"
 #include "PrototypeChain.hpp"
 #include <functional>
@@ -46,7 +46,7 @@ public:
 
 private:
   static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
-  using PrototypeCache = std::unordered_map<NativeInstanceId, OwningReference<jsi::Object>>;
+  using PrototypeCache = std::unordered_map<NativeInstanceId, BorrowingReference<jsi::Object>>;
   static std::unordered_map<jsi::Runtime*, PrototypeCache> _prototypeCache;
 
 protected:

package/cpp/utils/BorrowingReference.hpp

@@ -1,119 +1,226 @@
 //
 //  BorrowingReference.hpp
-//  NitroModules
+//  react-native-nitro
 //
-//  Created by Marc Rousavy on 21.06.24.
+//  Created by Marc Rousavy on 23.06.24.
 //
 
 #pragma once
 
+#include "NitroDefines.hpp"
+#include "OwningLock.hpp"
+#include "ReferenceState.hpp"
+#include "WeakReference.hpp"
 #include <atomic>
 #include <cstddef>
 #include <mutex>
 
 namespace margelo::nitro {
 
-// forward-declaration to avoid duplicate symbols
-template <typename T>
-class OwningReference;
-
 /**
- A `BorrowingReference<T>` is a weak reference to a pointer created by `OwningReference<T>`.
- It can be locked to gain a strong `OwningReference<T>` again if it has not been deleted yet.
+ An `BorrowingReference<T>` is a smart-pointer that holds a strong reference to a pointer.
+ You can have multiple `BorrowingReference<T>` instances point to the same pointer, as they internally keep a ref-count.
+ As opposed to a `shared_ptr<T>`, an `BorrowingReference<T>` can also be imperatively manually deleted, even if there
+ are multiple strong references still holding onto the pointer.
+ This is useful in cases where the `BorrowingReference` might keep a reference alive, but an external value holder
+ is actually responsible for truly deleting the underlying value - like a `jsi::Runtime` for a `jsi::Value`.
+
+ An `BorrowingReference<T>` can be weakified, which gives the user a `WeakReference<T>`.
+ A `WeakReference<T>` can be locked to get an `BorrowingReference<T>` again, assuming it has not been deleted yet.
+
+ A `BorrowingReference<T>` can also be locked using `lock()`, which gives the user an `OwningLock<T>`.
+ Only an `OwningLock<T>` guarantees safe access to the underlying value reference, as any external value holders
+ that might try to delete the value will have to wait until the lock is freed again.
  */
 template <typename T>
 class BorrowingReference final {
-private:
-  explicit BorrowingReference(const OwningReference<T>& ref);
-
 public:
-  BorrowingReference() : _value(nullptr), _isDeleted(nullptr), _strongRefCount(nullptr), _weakRefCount(nullptr), _mutex(nullptr) {}
+  BorrowingReference() : _value(nullptr), _state(nullptr) {}
 
-  BorrowingReference(const BorrowingReference& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    if (_weakRefCount != nullptr) {
+  explicit BorrowingReference(T* value) : _value(value), _state(new ReferenceState()) {}
+
+  BorrowingReference(const BorrowingReference& ref) : _value(ref._value), _state(ref._state) {
+    if (_state != nullptr) {
       // increment ref count after copy
-      (*_weakRefCount)++;
+      _state->strongRefCount++;
     }
   }
 
-  BorrowingReference(BorrowingReference&& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
+  BorrowingReference(BorrowingReference&& ref) : _value(ref._value), _state(ref._state) {
     ref._value = nullptr;
-    ref._isDeleted = nullptr;
-    ref._strongRefCount = nullptr;
-    ref._weakRefCount = nullptr;
+    ref._state = nullptr;
   }
 
   BorrowingReference& operator=(const BorrowingReference& ref) {
     if (this == &ref)
       return *this;
 
-    if (_weakRefCount != nullptr) {
+    if (_state != nullptr) {
       // destroy previous pointer
-      (*_weakRefCount)--;
-      maybeDestroy();
+      bool shouldDestroy = _state->decrementStrongRefCount();
+      if (shouldDestroy) {
+        forceDestroyValue();
+      }
+      maybeDestroyState();
     }
 
     _value = ref._value;
-    _isDeleted = ref._isDeleted;
-    _strongRefCount = ref._strongRefCount;
-    _weakRefCount = ref._weakRefCount;
-    _mutex = ref._mutex;
-    if (_weakRefCount != nullptr) {
+    _state = ref._state;
+    if (_state != nullptr) {
       // increment new pointer
-      (*_weakRefCount)++;
+      _state->strongRefCount++;
     }
 
     return *this;
   }
 
+private:
+  // WeakReference<T> -> BorrowingReference<T> Lock-constructor
+  BorrowingReference(const WeakReference<T>& ref) : _value(ref._value), _state(ref._state) {
+    _state->strongRefCount++;
+  }
+
+private:
+  // BorrowingReference<C> -> BorrowingReference<T> Cast-constructor
+  template <typename OldT>
+  BorrowingReference(T* value, const BorrowingReference<OldT>& originalRef) : _value(value), _state(originalRef._state) {
+    _state->strongRefCount++;
+  }
+
+  template <typename C>
+  friend class BorrowingReference;
+
+public:
   ~BorrowingReference() {
-    if (_weakRefCount == nullptr) {
+    if (_state == nullptr) {
       // we are just a dangling nullptr.
       return;
     }
 
-    (*_weakRefCount)--;
-    maybeDestroy();
+    // decrement strong ref count on destroy
+    bool shouldDestroy = _state->decrementStrongRefCount();
+    if (shouldDestroy) {
+      forceDestroyValue();
+    }
+    maybeDestroyState();
+  }
+
+public:
+  /**
+   Casts this `BorrowingReference<T>` to a `BorrowingReference<C>`.
+   */
+  template <typename C>
+  BorrowingReference<C> as() {
+    return BorrowingReference<C>(static_cast<C*>(_value), *this);
+  }
+
+public:
+  /**
+   Creates an `OwningLock<T>` for the given `BorrowingReference<T>` to guarantee safe
+   safe access to `BorrowingReference<T>`.
+   Other threads (e.g. the Hermes garbage collector) cannot delete the `BorrowingReference<T>`
+   as long as the `OwningLock<T>` is still alive.
+   */
+  [[nodiscard]]
+  OwningLock<T> lock() const {
+    return OwningLock<T>(*this);
+  }
+
+  /**
+   Get whether the `BorrowingReference<T>` is still pointing to a valid value, or not.
+   */
+  inline bool hasValue() const {
+    return _value != nullptr && !_state->isDeleted;
   }
 
   /**
-   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   Get a borrowing (or "weak") reference to this owning reference
    */
   [[nodiscard]]
-  OwningReference<T> lock() const;
+  WeakReference<T> weak() const {
+    return WeakReference(*this);
+  }
+
+  /**
+   Delete and destroy the value this BorrowingReference is pointing to.
+   This can even be called if there are still multiple strong references to the value.
+
+   This will block as long as one or more `OwningLock<T>`s of this `BorrowingReference<T>` are still alive.
+   */
+  void destroy() {
+    std::unique_lock lock(_state->mutex);
+
+    forceDestroyValue();
+  }
 
 public:
-  friend class OwningReference<T>;
+  explicit inline operator bool() const {
+    return hasValue();
+  }
 
-private:
-  void maybeDestroy() {
-    _mutex->lock();
+  inline T& operator*() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (*) nullptr BorrowingReference<T>!");
+    }
+#endif
+    return *_value;
+  }
+
+  inline T* operator->() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (->) nullptr BorrowingReference<T>!");
+    }
+#endif
+    return _value;
+  }
+
+  inline bool operator==(T* other) const {
+    return _value == other;
+  }
+
+  inline bool operator!=(T* other) const {
+    return _value != other;
+  }
+
+  inline bool operator==(const BorrowingReference<T>& other) const {
+    return _value == other._value;
+  }
+
+  inline bool operator!=(const BorrowingReference<T>& other) const {
+    return _value != other._value;
+  }
 
-    if (*_strongRefCount == 0 && *_weakRefCount == 0) {
+private:
+  void maybeDestroyState() {
+    if (_state->strongRefCount == 0 && _state->weakRefCount == 0) {
       // free the full memory if there are no more references at all
-      if (!(*_isDeleted)) {
-        delete _value;
-      }
-      delete _isDeleted;
-      delete _strongRefCount;
-      delete _weakRefCount;
-      _mutex->unlock();
+      delete _state;
+      _state = nullptr;
       return;
     }
+  }
 
-    _mutex->unlock();
+  void forceDestroyValue() {
+    if (_state->isDeleted) [[unlikely]] {
+      // it has already been destroyed.
+      return;
+    }
+    delete _value;
+    _value = nullptr;
+    _state->isDeleted = true;
   }
 
+public:
+  friend class WeakReference<T>;
+  friend class OwningLock<T>;
+
 private:
   T* _value;
-  bool* _isDeleted;
-  std::atomic_size_t* _strongRefCount;
-  std::atomic_size_t* _weakRefCount;
-  std::recursive_mutex* _mutex;
+  ReferenceState* _state;
 };
 
 } // namespace margelo::nitro
+
+#include "WeakReference+Owning.hpp"

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.22.0"
+#define NITRO_VERSION "0.22.1"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG
@@ -52,10 +52,7 @@
 #define SWIFT_NONCOPYABLE
 #endif
 
-// React Native Support
-#if __has_include(<cxxreact/ReactNativeVersion.h>)
-#include <cxxreact/ReactNativeVersion.h>
-#endif
+// React Native Support (right now it's only stubbed out)
 #ifndef REACT_NATIVE_VERSION_MINOR
 #define REACT_NATIVE_VERSION_MAJOR 0
 #define REACT_NATIVE_VERSION_MINOR 0

package/cpp/utils/OwningLock.hpp

@@ -9,10 +9,10 @@
 
 namespace margelo::nitro {
 template <typename T>
-class OwningReference;
+class BorrowingReference;
 }
 
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <cstddef>
 #include <mutex>
 
@@ -20,21 +20,26 @@ namespace margelo::nitro {
 
 /**
  * An `OwningLock<T>` is a RAII instance that locks the given caller thread guaranteed safe access
- * to a `OwningReference<T>`.
- * The `OwningReference<T>` cannot be deleted while an `OwningLock<T>` of it is alive.
+ * to a `BorrowingReference<T>`.
+ * The `BorrowingReference<T>` cannot be deleted while an `OwningLock<T>` of it is alive.
  *
  * This is useful in JSI, because Hermes runs garbage collection on a separate Thread,
- * and the separate Thread can delete an `OwningReference<T>` while it's still in use.
+ * and the separate Thread can delete an `BorrowingReference<T>` while it's still in use.
  * The `OwningLock<T>` prevents exactly this problem by blocking the GC destructor until
  * the `OwningLock<T>` is released.
  *
- * To create an `OwningLock<T>`, simply call `lock()` on an `OwningReference<T>`.
+ * To create an `OwningLock<T>`, simply call `lock()` on an `BorrowingReference<T>`.
  */
 template <typename T>
 class OwningLock final {
+private:
+  explicit OwningLock(const BorrowingReference<T>& reference) : _reference(reference) {
+    _reference._state->mutex.lock();
+  }
+
 public:
   ~OwningLock() {
-    _reference._mutex->unlock();
+    _reference._state->mutex.unlock();
   }
 
   OwningLock() = delete;
@@ -42,15 +47,10 @@ public:
   OwningLock(OwningLock&&) = delete;
 
 private:
-  explicit OwningLock(const OwningReference<T>& reference) : _reference(reference) {
-    _reference._mutex->lock();
-  }
-
-private:
-  OwningReference<T> _reference;
+  BorrowingReference<T> _reference;
 
 private:
-  friend class OwningReference<T>;
+  friend class BorrowingReference<T>;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/ReferenceState.hpp

@@ -0,0 +1,40 @@
+//
+//  ReferenceState.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 03.02.24.
+//
+
+#pragma once
+
+#include <atomic>
+#include <mutex>
+
+namespace margelo::nitro {
+
+/**
+ * Holds state for an `BorrowingReference` (or `WeakReference`).
+ *
+ * The state tracks the amount of strong- and weak- references to any kind of value,
+ * including an extra `isDeleted` flag that specifies whether the value has been force-deleted.
+ *
+ * Also, a `mutex` allows for thread-safe access of the `isDeleted` flag.
+ */
+struct ReferenceState {
+  std::atomic_size_t strongRefCount;
+  std::atomic_size_t weakRefCount;
+  bool isDeleted;
+  std::mutex mutex;
+
+  /**
+   * Decrements the strong ref count by one, and returns whether the value should be deleted.
+   */
+  inline bool decrementStrongRefCount() {
+    size_t oldRefCount = strongRefCount.fetch_sub(1);
+    return oldRefCount <= 1;
+  }
+
+  explicit ReferenceState() : strongRefCount(1), weakRefCount(0), isDeleted(false) {}
+};
+
+} // namespace margelo::nitro

package/cpp/utils/WeakReference+Owning.hpp

@@ -0,0 +1,33 @@
+//
+//  WeakReference+Owning.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 23.06.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+
+namespace margelo::nitro {
+
+template <typename T>
+WeakReference<T>::WeakReference(const BorrowingReference<T>& ref) {
+  _value = ref._value;
+  _state = ref._state;
+  _state->weakRefCount++;
+}
+
+template <typename T>
+BorrowingReference<T> WeakReference<T>::lock() const {
+  std::unique_lock lock(_state->mutex);
+
+  if (_state->isDeleted) {
+    // return nullptr
+    return BorrowingReference<T>();
+  }
+
+  return BorrowingReference(*this);
+}
+
+} // namespace margelo::nitro

package/cpp/utils/WeakReference.hpp

@@ -0,0 +1,102 @@
+//
+//  WeakReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include "ReferenceState.hpp"
+#include <atomic>
+#include <cstddef>
+#include <mutex>
+
+namespace margelo::nitro {
+
+// forward-declaration to avoid duplicate symbols
+template <typename T>
+class BorrowingReference;
+
+/**
+ A `WeakReference<T>` is a weak reference to a pointer created by `BorrowingReference<T>`.
+ It can be locked to gain a strong `BorrowingReference<T>` again if it has not been deleted yet.
+ */
+template <typename T>
+class WeakReference final {
+private:
+  explicit WeakReference(const BorrowingReference<T>& ref);
+
+public:
+  WeakReference() : _value(nullptr), _state(nullptr) {}
+
+  WeakReference(const WeakReference& ref) : _value(ref._value), _state(ref._state) {
+    if (_state != nullptr) {
+      // increment ref count after copy
+      _state->weakRefCount++;
+    }
+  }
+
+  WeakReference(WeakReference&& ref) : _value(ref._value), _state(ref._state) {
+    // Remove state from other WeakReference after moving since it's now stale data
+    ref._value = nullptr;
+    ref._state = nullptr;
+  }
+
+  WeakReference& operator=(const WeakReference& ref) {
+    if (this == &ref)
+      return *this;
+
+    if (_state != nullptr) {
+      // destroy previous pointer
+      _state->weakRefCount--;
+      maybeDestroy();
+    }
+
+    _value = ref._value;
+    _state = ref._state;
+    if (_state != nullptr) {
+      // increment new pointer
+      _state->weakRefCount++;
+    }
+
+    return *this;
+  }
+
+  ~WeakReference() {
+    if (_state == nullptr) {
+      // we are just a dangling nullptr.
+      return;
+    }
+
+    _state->weakRefCount--;
+    maybeDestroy();
+  }
+
+  /**
+   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   */
+  [[nodiscard]]
+  BorrowingReference<T> lock() const;
+
+public:
+  friend class BorrowingReference<T>;
+
+private:
+  void maybeDestroy() {
+    if (_state->strongRefCount == 0 && _state->weakRefCount == 0) {
+      // free the full memory if there are no more references at all
+      if (!_state->isDeleted) [[unlikely]] {
+        throw std::runtime_error("WeakReference<T> encountered a stale _value - BorrowingReference<T> should've already deleted this!");
+      }
+      delete _state;
+      _state = nullptr;
+    }
+  }
+
+private:
+  T* _value;
+  ReferenceState* _state;
+};
+
+} // namespace margelo::nitro

package/cpp/views/CachedProp.hpp

@@ -4,9 +4,9 @@
 
 #pragma once
 
+#include "BorrowingReference.hpp"
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
-#include "OwningReference.hpp"
 #include <jsi/jsi.h>
 
 namespace margelo::nitro {
@@ -17,7 +17,7 @@ template <typename T>
 struct CachedProp {
 public:
   T value;
-  OwningReference<jsi::Value> jsiValue;
+  BorrowingReference<jsi::Value> jsiValue;
   bool isDirty = false;
 
 public:
@@ -35,7 +35,7 @@ public:
     }
     T converted = JSIConverter<T>::fromJSI(runtime, value);
     JSICacheReference cache = JSICache::getOrCreateCache(runtime);
-    OwningReference<jsi::Value> cached = cache.makeShared(jsi::Value(runtime, value));
+    BorrowingReference<jsi::Value> cached = cache.makeShared(jsi::Value(runtime, value));
     return CachedProp<T>(std::move(converted), std::move(cached), /* isDirty */ true);
   }
 };

package/ios/core/AnyMapHolder.swift

@@ -44,7 +44,7 @@ public indirect enum AnyValue {
 /**
  * Represents an `AnyMap` that can be passed to Swift.
  */
-public class AnyMapHolder {
+public final class AnyMapHolder {
   public let cppPart: margelo.nitro.TSharedMap
 
   public init() {
@@ -54,7 +54,7 @@ public class AnyMapHolder {
   public init(withPreallocatedSize size: Int) {
     cppPart = margelo.nitro.AnyMap.make(size)
   }
-  
+
   public init(withCppPart otherCppPart: margelo.nitro.TSharedMap) {
     cppPart = otherCppPart
   }
@@ -120,7 +120,7 @@ public class AnyMapHolder {
     let value = cppPart.pointee.getString(std.string(key))
     return String(value)
   }
-  
+
   /**
    * Gets the array value at the given key.
    * If no value exists at the given key, or if it is not a double,
@@ -130,7 +130,7 @@ public class AnyMapHolder {
     let value = cppPart.pointee.getArray(std.string(key))
     return value.toSwift()
   }
-  
+
   /**
    * Gets the object value at the given key.
    * If no value exists at the given key, or if it is not a double,
@@ -177,14 +177,14 @@ public class AnyMapHolder {
   public func setString(key: String, value: String) {
     cppPart.pointee.setString(std.string(key), std.string(value))
   }
-  
+
   /**
    * Set the given key to the given array value.
    */
   public func setArray(key: String, value: [AnyValue]) {
     cppPart.pointee.setArray(std.string(key), margelo.nitro.AnyArray.create(value))
   }
-  
+
   /**
    * Set the given key to the given object value.
    */
@@ -228,14 +228,14 @@ public class AnyMapHolder {
   public func isString(key: String) -> Bool {
     return cppPart.pointee.isString(std.string(key))
   }
-  
+
   /**
    * Gets whether the given `key` is holding an array value, or not.
    */
   public func isArray(key: String) -> Bool {
     return cppPart.pointee.isArray(std.string(key))
   }
-  
+
   /**
    * Gets whether the given `key` is holding an object value, or not.
    */

package/ios/turbomodule/NativeNitroModules+NewArch.mm

@@ -34,7 +34,7 @@ RCT_EXPORT_MODULE(NitroModules)
 
 - (void)installJSIBindingsWithRuntime:(jsi::Runtime&)runtime {
   // 1. Get CallInvoker we cached statically
-  auto callInvoker = _callInvoker.lock();
+  std::shared_ptr<react::CallInvoker> callInvoker = _callInvoker.lock();
   if (callInvoker == nullptr) {
     throw std::runtime_error("Cannot install global.NitroModulesProxy - CallInvoker was null!");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/cpp/utils/BorrowingReference+Owning.hpp

@@ -1,36 +0,0 @@
-//
-//  BorrowingReference+Owning.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 23.06.24.
-//
-
-#pragma once
-
-#include "OwningReference.hpp"
-
-namespace margelo::nitro {
-
-template <typename T>
-BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
-  _value = ref._value;
-  _isDeleted = ref._isDeleted;
-  _strongRefCount = ref._strongRefCount;
-  _weakRefCount = ref._weakRefCount;
-  _mutex = ref._mutex;
-  (*_weakRefCount)++;
-}
-
-template <typename T>
-OwningReference<T> BorrowingReference<T>::lock() const {
-  std::unique_lock lock(*_mutex);
-
-  if (*_isDeleted) {
-    // return nullptr
-    return OwningReference<T>();
-  }
-
-  return OwningReference(*this);
-}
-
-} // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -1,250 +0,0 @@
-//
-//  OwningReference.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 23.06.24.
-//
-
-#pragma once
-
-#include "BorrowingReference.hpp"
-#include "NitroDefines.hpp"
-#include "OwningLock.hpp"
-#include <atomic>
-#include <cstddef>
-#include <mutex>
-
-namespace margelo::nitro {
-
-/**
- An `OwningReference<T>` is a smart-pointer that holds a strong reference to a pointer.
- You can have multiple `OwningReference<T>` instances point to the same pointer, as they internally keep a ref-count.
- As opposed to a `shared_ptr<T>`, an `OwningReference<T>` can also be imperatively manually deleted, even if there
- are multiple strong references still holding onto the pointer.
-
- An `OwningReference<T>` can be weakified, which gives the user a `BorrowingReference<T>`.
- A `BorrowingReference<T>` can be locked to get an `OwningReference<T>` again, assuming it has not been deleted yet.
- */
-template <typename T>
-class OwningReference final {
-public:
-  using Pointee = T;
-
-public:
-  OwningReference() : _value(nullptr), _isDeleted(nullptr), _strongRefCount(nullptr), _weakRefCount(nullptr), _mutex(nullptr) {}
-
-  explicit OwningReference(T* value)
-      : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)),
-        _mutex(new std::recursive_mutex()) {}
-
-  OwningReference(const OwningReference& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    if (_strongRefCount != nullptr) {
-      // increment ref count after copy
-      (*_strongRefCount)++;
-    }
-  }
-
-  OwningReference(OwningReference&& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    ref._value = nullptr;
-    ref._isDeleted = nullptr;
-    ref._strongRefCount = nullptr;
-    ref._weakRefCount = nullptr;
-  }
-
-  OwningReference& operator=(const OwningReference& ref) {
-    if (this == &ref)
-      return *this;
-
-    if (_strongRefCount != nullptr) {
-      // destroy previous pointer
-      (*_strongRefCount)--;
-      maybeDestroy();
-    }
-
-    _value = ref._value;
-    _isDeleted = ref._isDeleted;
-    _strongRefCount = ref._strongRefCount;
-    _weakRefCount = ref._weakRefCount;
-    _mutex = ref._mutex;
-    if (_strongRefCount != nullptr) {
-      // increment new pointer
-      (*_strongRefCount)++;
-    }
-
-    return *this;
-  }
-
-private:
-  // BorrowingReference<T> -> OwningReference<T> Lock-constructor
-  OwningReference(const BorrowingReference<T>& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    (*_strongRefCount)++;
-  }
-
-private:
-  // OwningReference<C> -> OwningReference<T> Cast-constructor
-  template <typename OldT>
-  OwningReference(T* value, const OwningReference<OldT>& originalRef)
-      : _value(value), _isDeleted(originalRef._isDeleted), _strongRefCount(originalRef._strongRefCount),
-        _weakRefCount(originalRef._weakRefCount), _mutex(originalRef._mutex) {
-    (*_strongRefCount)++;
-  }
-
-  template <typename C>
-  friend class OwningReference;
-
-public:
-  ~OwningReference() {
-    if (_strongRefCount == nullptr) {
-      // we are just a dangling nullptr.
-      return;
-    }
-
-    // decrement strong ref count on destroy
-    --(*_strongRefCount);
-    maybeDestroy();
-  }
-
-public:
-  /**
-   Casts this `OwningReference<T>` to a `OwningReference<C>`.
-   */
-  template <typename C>
-  OwningReference<C> as() {
-    return OwningReference<C>(static_cast<C*>(_value), *this);
-  }
-
-public:
-  /**
-   Creates an `OwningLock<T>` for the given `OwningReference<T>` to guarantee safe
-   safe access to `OwningReference<T>`.
-   Other threads (e.g. the Hermes garbage collector) cannot delete the `OwningReference<T>`
-   as long as the `OwningLock<T>` is still alive.
-   */
-  [[nodiscard]]
-  OwningLock<T> lock() const {
-    return OwningLock<T>(*this);
-  }
-
-  /**
-   Get whether the `OwningReference<T>` is still pointing to a valid value, or not.
-   */
-  inline bool hasValue() const {
-    return _value != nullptr && !(*_isDeleted);
-  }
-
-  /**
-   Get a borrowing (or "weak") reference to this owning reference
-   */
-  [[nodiscard]]
-  BorrowingReference<T> weak() const {
-    return BorrowingReference(*this);
-  }
-
-  /**
-   Delete and destroy the value this OwningReference is pointing to.
-   This can even be called if there are still multiple strong references to the value.
-
-   This will block as long as one or more `OwningLock<T>`s of this `OwningReference<T>` are still alive.
-   */
-  void destroy() {
-    std::unique_lock lock(*_mutex);
-
-    forceDestroy();
-  }
-
-public:
-  explicit inline operator bool() const {
-    return hasValue();
-  }
-
-  inline T& operator*() const {
-#ifdef NITRO_DEBUG
-    if (!hasValue()) [[unlikely]] {
-      throw std::runtime_error("Tried to dereference (*) nullptr OwningReference<T>!");
-    }
-#endif
-    return *_value;
-  }
-
-  inline T* operator->() const {
-#ifdef NITRO_DEBUG
-    if (!hasValue()) [[unlikely]] {
-      throw std::runtime_error("Tried to dereference (->) nullptr OwningReference<T>!");
-    }
-#endif
-    return _value;
-  }
-
-  inline bool operator==(T* other) const {
-    std::unique_lock lock(*_mutex);
-
-    if (*_isDeleted) {
-      return other == nullptr;
-    } else {
-      return other == _value;
-    }
-  }
-
-  inline bool operator!=(T* other) const {
-    return !(this == other);
-  }
-
-  inline bool operator==(const OwningReference<T>& other) const {
-    return _value == other._value;
-  }
-
-  inline bool operator!=(const OwningReference<T>& other) const {
-    return !(this == other);
-  }
-
-private:
-  void maybeDestroy() {
-    _mutex->lock();
-
-    if (*_strongRefCount == 0) {
-      // after no strong references exist anymore
-      forceDestroy();
-    }
-
-    if (*_strongRefCount == 0 && *_weakRefCount == 0) {
-      // free the full memory if there are no more references at all
-      delete _isDeleted;
-      delete _strongRefCount;
-      delete _weakRefCount;
-      _mutex->unlock();
-      return;
-    }
-
-    _mutex->unlock();
-  }
-
-  void forceDestroy() {
-    if (*_isDeleted) {
-      // it has already been destroyed.
-      return;
-    }
-    delete _value;
-    *_isDeleted = true;
-  }
-
-public:
-  friend class BorrowingReference<T>;
-  friend class OwningLock<T>;
-
-private:
-  T* _value;
-  bool* _isDeleted;
-  std::atomic_size_t* _strongRefCount;
-  std::atomic_size_t* _weakRefCount;
-  std::recursive_mutex* _mutex;
-};
-
-} // namespace margelo::nitro
-
-#include "BorrowingReference+Owning.hpp"