react-native-nitro-modules 0.0.2 → 0.0.6

package/cpp/utils/BorrowingReference.hpp

@@ -0,0 +1,115 @@
+//
+//  BorrowingReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <cstddef>
+#include <mutex>
+#include <atomic>
+
+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.
+ */
+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(const BorrowingReference& ref)
+      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
+        _mutex(ref._mutex) {
+    // increment ref count after copy
+    (*_weakRefCount)++;
+  }
+
+  BorrowingReference(BorrowingReference&& 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;
+  }
+
+  BorrowingReference& operator=(const BorrowingReference& ref) {
+    if (this == &ref)
+      return *this;
+
+    if (_weakRefCount != nullptr) {
+      // destroy previous pointer
+      (*_weakRefCount)--;
+      maybeDestroy();
+    }
+
+    _value = ref._value;
+    _isDeleted = ref._isDeleted;
+    _strongRefCount = ref._strongRefCount;
+    _weakRefCount = ref._weakRefCount;
+    _mutex = ref._mutex;
+    if (_weakRefCount != nullptr) {
+      // increment new pointer
+      (*_weakRefCount)++;
+    }
+
+    return *this;
+  }
+
+  ~BorrowingReference() {
+    if (_weakRefCount == nullptr) {
+      // we are just a dangling nullptr.
+      return;
+    }
+
+    (*_weakRefCount)--;
+    maybeDestroy();
+  }
+
+  /**
+   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   */
+  [[nodiscard]]
+  OwningReference<T> lock();
+
+public:
+  friend class OwningReference<T>;
+
+private:
+  void maybeDestroy() {
+    _mutex->lock();
+
+    if (*_strongRefCount == 0 && *_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();
+      return;
+    }
+
+    _mutex->unlock();
+  }
+
+private:
+  T* _value;
+  bool* _isDeleted;
+  std::atomic_size_t* _strongRefCount;
+  std::atomic_size_t* _weakRefCount;
+  std::mutex* _mutex;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/DoesClassExist.hpp

@@ -0,0 +1,23 @@
+//
+//  DoesClassExist.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 17.07.24.
+//
+
+#pragma once
+
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// By default, it is false (class does not exist)
+template <typename T, typename = std::void_t<>> struct does_class_exist : std::false_type {};
+
+// If sizeof(T) can be a type (number), the type exists - so it is true
+template <typename T> struct does_class_exist<T, std::void_t<decltype(sizeof(T))>> : std::true_type {};
+
+// Direct value accessor for does_class_exist
+template <typename T> inline constexpr bool does_class_exist_v = does_class_exist<T>::value;
+
+} // namespace margelo::nitro

package/cpp/utils/GetRuntimeID.hpp

@@ -0,0 +1,28 @@
+//
+//  GetRuntimeID.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.06.24.
+//
+
+#pragma once
+
+#include "ThreadUtils.hpp"
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Get an ID for the given Runtime.
+ *
+ * The ID usually consists of a Runtime description (e.g. "HermesRuntime"),
+ * and it's Thread (e.g. "com.facebook.react.runtime.JavaScript")
+ */
+static inline std::string getRuntimeId(jsi::Runtime& runtime) {
+  std::string threadName = ThreadUtils::getThreadName();
+  return runtime.description() + std::string(" (") + threadName + std::string(")");
+}
+
+} // namespace margelo::nitro

package/cpp/utils/NitroDefines.hpp

@@ -0,0 +1,32 @@
+//
+//  NitroDefines.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 29.07.24.
+//
+
+#ifndef NitroDefines_h
+#define NitroDefines_h
+
+// Helper to find out if a C++ compiler attribute is available
+#ifdef __has_attribute
+#define _CXX_INTEROP_HAS_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define _CXX_INTEROP_HAS_ATTRIBUTE(x) 0
+#endif
+
+#if _CXX_INTEROP_HAS_ATTRIBUTE(swift_attr)
+// Rename Type for Swift
+#define SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
+#else
+#define SWIFT_NAME(_name)
+#endif
+
+#if _CXX_INTEROP_HAS_ATTRIBUTE(enum_extensibility)
+// Enum is marked as closed/not extensible
+#define CLOSED_ENUM __attribute__((enum_extensibility(closed)))
+#else
+#define CLOSED_ENUM
+#endif
+
+#endif /* NitroDefines_h */

package/cpp/utils/NitroHash.hpp

@@ -0,0 +1,42 @@
+//
+//  NitroHash.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace margelo::nitro {
+
+/**
+ * Hashes the given C-String using the FNV-1a hashing algorithm.
+ *
+ * This function can be used at compile time as a constexpr to build
+ * statically optimized switch statements.
+ */
+constexpr uint64_t hashString(const char* str, size_t length) {
+  uint64_t hash = 14695981039346656037ull; // FNV offset basis
+  const uint64_t fnv_prime = 1099511628211ull;
+
+  for (size_t i = 0; i < length; ++i) {
+    hash ^= static_cast<uint64_t>(str[i]);
+    hash *= fnv_prime;
+  }
+
+  return hash;
+}
+
+/**
+ * Hashes the given constant C-String using the FNV-1a hashing algorithm.
+ *
+ * String length is known at compile time.
+ */
+template <size_t N> constexpr uint64_t hashString(const char (&str)[N]) {
+  return hashString(str, N - 1); // N includes the null terminator, so subtract 1
+}
+
+} // namespace margelo::nitro

package/cpp/utils/NitroLogger.hpp

@@ -0,0 +1,55 @@
+//
+// Created by Marc Rousavy on 05.03.24.
+//
+
+#pragma once
+
+#include <cstdarg>
+#include <cstdio>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro {
+
+class Logger final {
+private:
+  Logger() = delete;
+
+public:
+  template <typename... Args> static void log(const char* tag, const char* message, Args&&... args) {
+    std::string formattedMessage = format(message, std::forward<Args>(args)...);
+    std::cout << "[Nitro." << tag << "] " << formattedMessage << std::endl;
+  }
+
+private:
+  template <typename... Args> static inline std::string format(const char* formatString, Args&&... args) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-security"
+    int size_s = std::snprintf(nullptr, 0, formatString, toCString(args)...) + 1; // Extra space for '\0'
+    if (size_s <= 0) [[unlikely]] {
+      throw std::runtime_error("Failed to format log message \"" + std::string(formatString) + "\"!");
+    }
+    auto size = static_cast<size_t>(size_s);
+    std::vector<char> buf(size);
+    std::snprintf(buf.data(), size, formatString, toCString(args)...);
+    return std::string(buf.data(), buf.data() + size - 1); // We don't want the '\0' inside
+#pragma clang diagnostic pop
+  }
+
+private:
+  // When the user passes an `std::string`, it will automatically be converted to a `const char*`
+  static inline const char* toCString(const std::string& s) {
+    return s.c_str();
+  }
+  // When the user passes a `const char*`, we don't want to implicitly convert to `std::string`, so block that
+  static inline const char* toCString(const char* s) {
+    return s;
+  }
+  // When the user passes any other type, just return that directly.
+  template <typename T> static inline T toCString(T value) {
+    return value;
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/utils/OwningLock.hpp

@@ -0,0 +1,54 @@
+//
+//  OwningLock.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+template <typename T> class OwningReference;
+}
+
+#include "OwningReference.hpp"
+#include <cstddef>
+#include <mutex>
+
+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.
+ *
+ * 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.
+ * 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>`.
+ */
+template <typename T> class OwningLock final {
+public:
+  ~OwningLock() {
+    _reference._mutex->unlock();
+  }
+
+  OwningLock() = delete;
+  OwningLock(const OwningLock&) = delete;
+  OwningLock(OwningLock&&) = delete;
+
+private:
+  explicit OwningLock(const OwningReference<T>& reference) : _reference(reference) {
+    _reference._mutex->lock();
+  }
+
+private:
+  OwningReference<T> _reference;
+
+private:
+  friend class OwningReference<T>;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -0,0 +1,214 @@
+//
+//  OwningReference.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 23.06.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include "OwningLock.hpp"
+#include <cstddef>
+#include <mutex>
+#include <atomic>
+
+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::mutex()) {
+  }
+
+  OwningReference(const OwningReference& ref)
+      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
+        _mutex(ref._mutex) {
+    // 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:
+  OwningReference(const BorrowingReference<T>& ref)
+      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
+        _mutex(ref._mutex) {
+    (*_strongRefCount)++;
+  }
+
+public:
+  ~OwningReference() {
+    if (_strongRefCount == nullptr) {
+      // we are just a dangling nullptr.
+      return;
+    }
+
+    // decrement strong ref count on destroy
+    --(*_strongRefCount);
+    maybeDestroy();
+  }
+
+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 {
+    return *_value;
+  }
+
+  inline T* operator->() const {
+    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::mutex* _mutex;
+};
+
+} // namespace margelo::nitro
+
+#include "BorrowingReference+Owning.hpp"

package/cpp/utils/TypeInfo.hpp

@@ -0,0 +1,81 @@
+//
+//  TypeInfo.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 17.07.24.
+//
+
+#pragma once
+
+#include <regex>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#if __has_include(<cxxabi.h>)
+#include <cxxabi.h>
+#endif
+
+namespace margelo::nitro {
+
+struct TypeInfo final {
+public:
+  TypeInfo() = delete;
+
+  /**
+   * Get the name of the currently thrown exception
+   */
+  static inline const char* getCurrentExceptionName() {
+#if __has_include(<cxxabi.h>)
+    return __cxxabiv1::__cxa_current_exception_type()->name();
+#else
+    return "<unknown>";
+#endif
+  }
+
+  static inline std::string replaceRegex(const std::string& original, const std::string& pattern, const std::string& replacement) {
+    std::regex re(pattern);
+    return std::regex_replace(original, re, replacement);
+  }
+
+  /**
+   * Get a friendly name of the type `T` (if possible, demangled)
+   */
+  template <typename T> static inline std::string getFriendlyTypename() {
+    std::string name = typeid(T).name();
+#if __has_include(<cxxabi.h>)
+    int status = 0;
+    char* demangled_name = abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
+    if (demangled_name != nullptr) {
+      name = demangled_name;
+      std::free(demangled_name);
+    }
+#endif
+
+    // Make a few edge-cases nicer.
+    name = replaceRegex(name, R"(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>)", "std::string");
+    name = replaceRegex(name, R"(std::__1::vector<([^>]+), std::__1::allocator<\1>>)", "std::vector<$1>");
+    name = replaceRegex(name, R"(std::__1::map<([^,]+), ([^>]+), std::__1::less<\1>, std::__1::allocator<std::__1::pair<const \1, \2>>>)",
+                        "std::map<$1, $2>");
+    name = replaceRegex(name, R"(std::__1::shared_ptr<([^>]+)>)", "std::shared_ptr<$1>");
+    name = replaceRegex(name, R"(std::__1::unique_ptr<([^>]+), std::__1::default_delete<\1>>)", "std::unique_ptr<$1>");
+    name = replaceRegex(
+        name,
+        R"(std::__1::unordered_map<([^,]+), ([^>]+), std::__1::hash<\1>, std::__1::equal_to<\1>, std::__1::allocator<std::__1::pair<const \1, \2>>>)",
+        "std::unordered_map<$1, $2>");
+    name = replaceRegex(name, R"(std::__1::unordered_set<([^>]+), std::__1::hash<\1>, std::__1::equal_to<\1>, std::__1::allocator<\1>>)",
+                        "std::unordered_set<$1>");
+    name = replaceRegex(name, R"(std::__1::list<([^>]+), std::__1::allocator<\1>>)", "std::list<$1>");
+
+    return name;
+  }
+
+  template <typename... Types> static inline std::string getFriendlyTypenames() {
+    std::ostringstream stream;
+    ((stream << TypeInfo::getFriendlyTypename<Types>() << ", "), ...);
+    std::string string = stream.str();
+    return string.substr(0, string.length() - 2);
+  }
+};
+
+} // namespace margelo::nitro

package/ios/core/HybridObjectSpec.swift

@@ -0,0 +1,52 @@
+//
+//  HybridObjectSpec.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 23.07.24.
+//
+
+import Foundation
+
+/**
+ * A base protocol for all Swift-based Hybrid Objects.
+ */
+public protocol HybridObjectSpec {
+  /**
+   * Holds the C++ HybridObject and it's context.
+   * Use the default initializer in your implementation, C++ will set and get this value.
+   *
+   * @example
+   * ```swift
+   * var hybridContext = margelo.nitro.HybridContext()
+   * ```
+   */
+  var hybridContext: margelo.nitro.HybridContext { get set }
+
+  /**
+   * Get the memory size of the Swift instance (plus any external heap allocations),
+   * in bytes.
+   *
+   * Override this to allow tracking heap allocations such as buffers or images,
+   * which will help the JS GC be more efficient in deleting large unused objects.
+   *
+   * @example
+   * ```swift
+   * var memorySize: Int {
+   *   let imageSize = self.uiImage.bytesPerRow * self.uiImage.height
+   *   return getSizeOf(self) + imageSize
+   * }
+   * ```
+   */
+  var memorySize: Int { get }
+}
+
+public extension HybridObjectSpec {
+  /**
+   * Get the memory size of the given instance.
+   * This only accounts for stack allocated member variables,
+   * not for externally allocated heap allocations like images or buffers.
+   */
+  func getSizeOf<T: AnyObject>(_ instance: T) -> Int {
+    return malloc_size(Unmanaged.passUnretained(instance).toOpaque())
+  }
+}