react-native-wgpu 0.4.2 → 0.5.1

package/cpp/jsi/RNFPointerHolder.h

@@ -1,95 +0,0 @@
-//
-// Created by Marc Rousavy on 16.04.24.
-//
-
-#pragma once
-
-#include "RNFHybridObject.h"
-#include "RNFLogger.h"
-#include <memory>
-#include <mutex>
-#include <utility>
-#include <string>
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-template <typename T> class PointerHolder : public HybridObject {
-protected:
-  // no default constructor
-  PointerHolder() = delete;
-
-  /**
-   * Create a new instance of a pointer holder which holds the given shared_ptr.
-   * @param name The name of the implementing class, for example "ViewWrapper".
-   * @param pointer The pointer this class will hold. It might be released from JS at any point via `release()`.
-   */
-  PointerHolder(const char* name, std::shared_ptr<T> pointer) : HybridObject(name), _name(name), _pointer(pointer) {
-    // eagerly initialize the release() method instead of putting it in `loadHybridMethods`
-    registerHybridMethod("release", &PointerHolder<T>::release, this);
-    registerHybridGetter("isValid", &PointerHolder<T>::getIsValid, this);
-  }
-
-  /**
-   * Create a new instance of a pointer holder which holds a shared_ptr of the given value.
-   * The shared_ptr will be move-constructed.
-   * @param name The name of the implementing class, for example "ViewWrapper".
-   * @param value The value this class will hold as a shared_ptr. It might be destroyed from JS at any point via `release()`.
-   */
-  PointerHolder(const char* name, T&& value) : PointerHolder(name, std::make_shared<T>(std::move(value))) {}
-
-  /**
-   * Called when the PointerHolder gets automatically destroyed (e.g. via GC) and the shared_ptr will be destroyed.
-   */
-  ~PointerHolder() {
-    if (_pointer != nullptr) {
-      Logger::log(TAG, "Automatically releasing %s... (~PointerHolder())", _name.c_str());
-    }
-  }
-
-protected:
-  /**
-   * Manually release this reference to the pointer.
-   * If there are any other references to this pointer, no memory will be force-deleted.
-   */
-  virtual void release() {
-    std::unique_lock lock(_mutex);
-
-    if (_pointer == nullptr) {
-      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
-    }
-    Logger::log(TAG, "Manually releasing %s... (PointerHolder::release())", _name.c_str());
-    _pointer = nullptr;
-  }
-
-  /**
-   * Get the shared_ptr this class is holding.
-   * If it has already been manually released from JS, this method will throw a runtime_error.
-   */
-  std::shared_ptr<T> pointee() {
-    std::unique_lock lock(_mutex);
-
-    if (_pointer == nullptr) {
-      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
-    }
-    return _pointer;
-  }
-
-  /**
-   * Get if the pointer is still valid and strong.
-   */
-  bool getIsValid() {
-    std::unique_lock lock(_mutex);
-
-    return _pointer != nullptr;
-  }
-
-private:
-  std::string _name;
-  std::shared_ptr<T> _pointer;
-  std::mutex _mutex;
-  static constexpr auto TAG = "PointerHolder";
-};
-
-} // namespace margelo

package/cpp/jsi/RNFRuntimeState.cpp

@@ -1,18 +0,0 @@
-#include "RNFRuntimeState.h"
-
-namespace rnwgpu {
-
-const facebook::jsi::UUID RNFRuntimeState::kRuntimeStateKey = facebook::jsi::UUID();
-
-std::shared_ptr<RNFRuntimeState> RNFRuntimeState::get(facebook::jsi::Runtime& runtime) {
-  auto existing = runtime.getRuntimeData(kRuntimeStateKey);
-  if (existing) {
-    return std::static_pointer_cast<RNFRuntimeState>(existing);
-  }
-
-  auto state = std::shared_ptr<RNFRuntimeState>(new RNFRuntimeState());
-  runtime.setRuntimeData(kRuntimeStateKey, state);
-  return state;
-}
-
-} // namespace rnwgpu

package/cpp/jsi/RNFRuntimeState.h

@@ -1,106 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Runtime state management using Hermes' runtime.setRuntimeData API.
- * This replaces the old RuntimeLifecycleMonitor/RuntimeAwareCache system.
- */
-class RNFRuntimeState {
-public:
-  // UUID key for storing our runtime state
-  static const jsi::UUID kRuntimeStateKey;
-
-  /**
-   * Get or create the runtime state for the given runtime
-   */
-  static std::shared_ptr<RNFRuntimeState> get(jsi::Runtime& runtime);
-
-  /**
-   * Template cache that can store any type T per object pointer
-   */
-  template <typename T>
-  class ObjectCache {
-  public:
-    std::shared_ptr<T> getOrCreate(void* object) {
-      std::lock_guard<std::mutex> lock(mutex_);
-      auto it = cache_.find(object);
-      if (it != cache_.end()) {
-        return it->second;
-      }
-
-      auto value = std::make_shared<T>();
-      cache_[object] = value;
-      return value;
-    }
-
-    void remove(void* object) {
-      std::lock_guard<std::mutex> lock(mutex_);
-      cache_.erase(object);
-    }
-
-    void clear() {
-      std::lock_guard<std::mutex> lock(mutex_);
-      cache_.clear();
-    }
-
-  private:
-    std::mutex mutex_;
-    std::unordered_map<void*, std::shared_ptr<T>> cache_;
-  };
-
-  /**
-   * Get or create a cache for a specific type T
-   */
-  template <typename T>
-  std::shared_ptr<ObjectCache<T>> getCache() {
-    std::lock_guard<std::mutex> lock(mutex_);
-
-    // Use type_info as key for the cache type
-    const std::type_info& typeId = typeid(T);
-    auto it = typeCaches_.find(&typeId);
-
-    if (it != typeCaches_.end()) {
-      return std::static_pointer_cast<ObjectCache<T>>(it->second);
-    }
-
-    auto cache = std::make_shared<ObjectCache<T>>();
-    typeCaches_[&typeId] = cache;
-    return cache;
-  }
-
-private:
-  RNFRuntimeState() = default;
-
-  std::mutex mutex_;
-  // Map from type_info to cache instance
-  std::unordered_map<const std::type_info*, std::shared_ptr<void>> typeCaches_;
-};
-
-/**
- * Template helper for runtime-aware caching compatible with the old API
- * This provides a migration path from RuntimeAwareCache
- */
-template <typename T>
-class RuntimeAwareCache {
-public:
-  T& get(jsi::Runtime& rt) {
-    auto state = RNFRuntimeState::get(rt);
-    auto cache = state->getCache<T>();
-
-    // For compatibility, we use the runtime pointer as the object key
-    auto ptr = cache->getOrCreate(&rt);
-    return *ptr;
-  }
-};
-
-} // namespace rnwgpu