react-native-yolo 0.0.5 → 0.0.7

package/nitrogen/generated/android/c++/JHybridYoloModelSpec.cpp

@@ -0,0 +1,78 @@
+///
+/// JHybridYoloModelSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridYoloModelSpec.hpp"
+
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
+
+#include "Detection.hpp"
+#include <vector>
+#include "JDetection.hpp"
+#include "BoundingBox.hpp"
+#include "JBoundingBox.hpp"
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+#include <VisionCamera/JHybridFrameSpec.hpp>
+
+namespace margelo::nitro::yolo {
+
+  std::shared_ptr<JHybridYoloModelSpec> JHybridYoloModelSpec::JavaPart::getJHybridYoloModelSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridYoloModelSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridYoloModelSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridYoloModelSpec::CxxPart::jhybriddata> JHybridYoloModelSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridYoloModelSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridYoloModelSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridYoloModelSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridYoloModelSpec>(castJavaPart);
+  }
+
+  void JHybridYoloModelSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridYoloModelSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::vector<Detection> JHybridYoloModelSpec::detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDetection>>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("detect");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<Detection> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+  void JHybridYoloModelSpec::close() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("close");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JHybridYoloModelSpec.hpp

@@ -0,0 +1,64 @@
+///
+/// HybridYoloModelSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridYoloModelSpec.hpp"
+
+
+
+
+namespace margelo::nitro::yolo {
+
+  using namespace facebook;
+
+  class JHybridYoloModelSpec: public virtual HybridYoloModelSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/HybridYoloModelSpec;";
+      std::shared_ptr<JHybridYoloModelSpec> getJHybridYoloModelSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/HybridYoloModelSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridYoloModelSpec(const jni::local_ref<JHybridYoloModelSpec::JavaPart>& javaPart):
+      HybridObject(HybridYoloModelSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridYoloModelSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridYoloModelSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
+    void close() override;
+
+  private:
+    jni::global_ref<JHybridYoloModelSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JHybridYoloSpec.cpp

@@ -7,20 +7,15 @@
 
 #include "JHybridYoloSpec.hpp"
 
-// Forward declaration of `Detection` to properly resolve imports.
-namespace margelo::nitro::yolo { struct Detection; }
-// Forward declaration of `BoundingBox` to properly resolve imports.
-namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 
-#include <string>
-#include "Detection.hpp"
-#include <vector>
-#include "JDetection.hpp"
-#include "BoundingBox.hpp"
-#include "JBoundingBox.hpp"
 #include <memory>
+#include "HybridYoloModelSpec.hpp"
+#include "JHybridYoloModelSpec.hpp"
+#include <string>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <VisionCamera/JHybridFrameSpec.hpp>
 
@@ -57,33 +52,15 @@ namespace margelo::nitro::yolo {
   
 
   // Methods
-  double JHybridYoloSpec::sum(double num1, double num2) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double(double /* num1 */, double /* num2 */)>("sum");
-    auto __result = method(_javaPart, num1, num2);
-    return __result;
-  }
-  void JHybridYoloSpec::loadModel(const std::string& modelPath) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* modelPath */)>("loadModel");
-    method(_javaPart, jni::make_jstring(modelPath));
+  std::shared_ptr<HybridYoloModelSpec> JHybridYoloSpec::loadModel(const std::string& modelPath) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridYoloModelSpec::JavaPart>(jni::alias_ref<jni::JString> /* modelPath */)>("loadModel");
+    auto __result = method(_javaPart, jni::make_jstring(modelPath));
+    return __result->getJHybridYoloModelSpec();
   }
   std::string JHybridYoloSpec::frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("frameToBase64");
     auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
     return __result->toStdString();
   }
-  std::vector<Detection> JHybridYoloSpec::detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDetection>>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("detect");
-    auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
-    return [&](auto&& __input) {
-      size_t __size = __input->size();
-      std::vector<Detection> __vector;
-      __vector.reserve(__size);
-      for (size_t __i = 0; __i < __size; __i++) {
-        auto __element = __input->getElement(__i);
-        __vector.push_back(__element->toCpp());
-      }
-      return __vector;
-    }(__result);
-  }
 
 } // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JHybridYoloSpec.hpp

@@ -54,10 +54,8 @@ namespace margelo::nitro::yolo {
 
   public:
     // Methods
-    double sum(double num1, double num2) override;
-    void loadModel(const std::string& modelPath) override;
+    std::shared_ptr<HybridYoloModelSpec> loadModel(const std::string& modelPath) override;
     std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
-    std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
 
   private:
     jni::global_ref<JHybridYoloSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloModelSpec.kt

@@ -0,0 +1,59 @@
+///
+/// HybridYoloModelSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.yolo
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the YoloModel HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of YoloModel.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridYoloModelSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun detect(frame: com.margelo.nitro.camera.HybridFrameSpec): Array<Detection>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun close(): Unit
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject YoloModel]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridYoloModelSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridYoloModelSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridYoloModelSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloSpec.kt

@@ -31,19 +31,11 @@ abstract class HybridYoloSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun sum(num1: Double, num2: Double): Double
-  
-  @DoNotStrip
-  @Keep
-  abstract fun loadModel(modelPath: String): Unit
+  abstract fun loadModel(modelPath: String): HybridYoloModelSpec
   
   @DoNotStrip
   @Keep
   abstract fun frameToBase64(frame: com.margelo.nitro.camera.HybridFrameSpec): String
-  
-  @DoNotStrip
-  @Keep
-  abstract fun detect(frame: com.margelo.nitro.camera.HybridFrameSpec): Array<Detection>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Bridge.cpp

@@ -8,6 +8,7 @@
 #include "Yolo-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
+#include "HybridYoloModelSpecSwift.hpp"
 #include "HybridYoloSpecSwift.hpp"
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
@@ -25,6 +26,22 @@ namespace margelo::nitro::yolo::bridge::swift {
     return margelo::nitro::camera::bridge::swift::get_std__shared_ptr_HybridFrameSpec_(cppType);
   }
   
+  // pragma MARK: std::shared_ptr<HybridYoloModelSpec>
+  std::shared_ptr<HybridYoloModelSpec> create_std__shared_ptr_HybridYoloModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    Yolo::HybridYoloModelSpec_cxx swiftPart = Yolo::HybridYoloModelSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::yolo::HybridYoloModelSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridYoloModelSpec_(std__shared_ptr_HybridYoloModelSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::yolo::HybridYoloModelSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::yolo::HybridYoloModelSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridYoloModelSpec\" is not implemented in Swift!");
+    }
+    #endif
+    Yolo::HybridYoloModelSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridYoloSpec>
   std::shared_ptr<HybridYoloSpec> create_std__shared_ptr_HybridYoloSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     Yolo::HybridYoloSpec_cxx swiftPart = Yolo::HybridYoloSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Bridge.hpp

@@ -14,18 +14,23 @@ namespace margelo::nitro::yolo { struct BoundingBox; }
 namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
 namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
 namespace VisionCamera { class HybridFrameSpec_cxx; }
+// Forward declaration of `HybridYoloModelSpec_cxx` to properly resolve imports.
+namespace Yolo { class HybridYoloModelSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Include C++ defined types
 #include "BoundingBox.hpp"
 #include "Detection.hpp"
+#include "HybridYoloModelSpec.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
@@ -40,6 +45,17 @@ namespace Yolo { class HybridYoloSpec_cxx; }
  */
 namespace margelo::nitro::yolo::bridge::swift {
 
+  // pragma MARK: std::vector<Detection>
+  /**
+   * Specialized version of `std::vector<Detection>`.
+   */
+  using std__vector_Detection_ = std::vector<Detection>;
+  inline std::vector<Detection> create_std__vector_Detection_(size_t size) noexcept {
+    std::vector<Detection> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>`.
@@ -52,15 +68,34 @@ namespace margelo::nitro::yolo::bridge::swift {
   using std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>;
   inline std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::vector<Detection>
+  // pragma MARK: std::shared_ptr<HybridYoloModelSpec>
   /**
-   * Specialized version of `std::vector<Detection>`.
+   * Specialized version of `std::shared_ptr<HybridYoloModelSpec>`.
    */
-  using std__vector_Detection_ = std::vector<Detection>;
-  inline std::vector<Detection> create_std__vector_Detection_(size_t size) noexcept {
-    std::vector<Detection> vector;
-    vector.reserve(size);
-    return vector;
+  using std__shared_ptr_HybridYoloModelSpec_ = std::shared_ptr<HybridYoloModelSpec>;
+  std::shared_ptr<HybridYoloModelSpec> create_std__shared_ptr_HybridYoloModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridYoloModelSpec_(std__shared_ptr_HybridYoloModelSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridYoloModelSpec>
+  using std__weak_ptr_HybridYoloModelSpec_ = std::weak_ptr<HybridYoloModelSpec>;
+  inline std__weak_ptr_HybridYoloModelSpec_ weakify_std__shared_ptr_HybridYoloModelSpec_(const std::shared_ptr<HybridYoloModelSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<Detection>>
+  using Result_std__vector_Detection__ = Result<std::vector<Detection>>;
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::vector<Detection>& value) noexcept {
+    return Result<std::vector<Detection>>::withValue(value);
+  }
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Detection>>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
   }
   
   // pragma MARK: std::shared_ptr<HybridYoloSpec>
@@ -75,22 +110,13 @@ namespace margelo::nitro::yolo::bridge::swift {
   using std__weak_ptr_HybridYoloSpec_ = std::weak_ptr<HybridYoloSpec>;
   inline std__weak_ptr_HybridYoloSpec_ weakify_std__shared_ptr_HybridYoloSpec_(const std::shared_ptr<HybridYoloSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<double>
-  using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) noexcept {
-    return Result<double>::withValue(std::move(value));
+  // pragma MARK: Result<std::shared_ptr<HybridYoloModelSpec>>
+  using Result_std__shared_ptr_HybridYoloModelSpec__ = Result<std::shared_ptr<HybridYoloModelSpec>>;
+  inline Result_std__shared_ptr_HybridYoloModelSpec__ create_Result_std__shared_ptr_HybridYoloModelSpec__(const std::shared_ptr<HybridYoloModelSpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridYoloModelSpec>>::withValue(value);
   }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
-    return Result<double>::withError(error);
-  }
-  
-  // pragma MARK: Result<void>
-  using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() noexcept {
-    return Result<void>::withValue();
-  }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
-    return Result<void>::withError(error);
+  inline Result_std__shared_ptr_HybridYoloModelSpec__ create_Result_std__shared_ptr_HybridYoloModelSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridYoloModelSpec>>::withError(error);
   }
   
   // pragma MARK: Result<std::string>
@@ -101,14 +127,5 @@ namespace margelo::nitro::yolo::bridge::swift {
   inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
     return Result<std::string>::withError(error);
   }
-  
-  // pragma MARK: Result<std::vector<Detection>>
-  using Result_std__vector_Detection__ = Result<std::vector<Detection>>;
-  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::vector<Detection>& value) noexcept {
-    return Result<std::vector<Detection>>::withValue(value);
-  }
-  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::exception_ptr& error) noexcept {
-    return Result<std::vector<Detection>>::withError(error);
-  }
 
 } // namespace margelo::nitro::yolo::bridge::swift

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Umbrella.hpp

@@ -14,12 +14,15 @@ namespace margelo::nitro::yolo { struct BoundingBox; }
 namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
 namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Include C++ defined types
 #include "BoundingBox.hpp"
 #include "Detection.hpp"
+#include "HybridYoloModelSpec.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
@@ -40,6 +43,8 @@ namespace margelo::nitro::yolo { class HybridYoloSpec; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
 namespace VisionCamera { class HybridFrameSpec_cxx; }
+// Forward declaration of `HybridYoloModelSpec_cxx` to properly resolve imports.
+namespace Yolo { class HybridYoloModelSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 

package/nitrogen/generated/ios/c++/HybridYoloModelSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridYoloModelSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridYoloModelSpecSwift.hpp"
+
+namespace margelo::nitro::yolo {
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/ios/c++/HybridYoloModelSpecSwift.hpp

@@ -0,0 +1,97 @@
+///
+/// HybridYoloModelSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridYoloModelSpec.hpp"
+
+// Forward declaration of `HybridYoloModelSpec_cxx` to properly resolve imports.
+namespace Yolo { class HybridYoloModelSpec_cxx; }
+
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
+
+#include "Detection.hpp"
+#include <vector>
+#include "BoundingBox.hpp"
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+
+#include "Yolo-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::yolo {
+
+  /**
+   * The C++ part of HybridYoloModelSpec_cxx.swift.
+   *
+   * HybridYoloModelSpecSwift (C++) accesses HybridYoloModelSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridYoloModelSpec_cxx can directly inherit from the C++ class HybridYoloModelSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridYoloModelSpecSwift: public virtual HybridYoloModelSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridYoloModelSpecSwift(const Yolo::HybridYoloModelSpec_cxx& swiftPart):
+      HybridObject(HybridYoloModelSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline Yolo::HybridYoloModelSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridYoloModelSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
+      auto __result = _swiftPart.detect(frame);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void close() override {
+      auto __result = _swiftPart.close();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    Yolo::HybridYoloModelSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/ios/c++/HybridYoloSpecSwift.hpp

@@ -12,19 +12,15 @@
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 
+// Forward declaration of `HybridYoloModelSpec` to properly resolve imports.
+namespace margelo::nitro::yolo { class HybridYoloModelSpec; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
-// Forward declaration of `Detection` to properly resolve imports.
-namespace margelo::nitro::yolo { struct Detection; }
-// Forward declaration of `BoundingBox` to properly resolve imports.
-namespace margelo::nitro::yolo { struct BoundingBox; }
 
-#include <string>
 #include <memory>
+#include "HybridYoloModelSpec.hpp"
+#include <string>
 #include <VisionCamera/HybridFrameSpec.hpp>
-#include "Detection.hpp"
-#include <vector>
-#include "BoundingBox.hpp"
 
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 
@@ -76,20 +72,14 @@ namespace margelo::nitro::yolo {
 
   public:
     // Methods
-    inline double sum(double num1, double num2) override {
-      auto __result = _swiftPart.sum(std::forward<decltype(num1)>(num1), std::forward<decltype(num2)>(num2));
+    inline std::shared_ptr<HybridYoloModelSpec> loadModel(const std::string& modelPath) override {
+      auto __result = _swiftPart.loadModel(modelPath);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void loadModel(const std::string& modelPath) override {
-      auto __result = _swiftPart.loadModel(modelPath);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-    }
     inline std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
       auto __result = _swiftPart.frameToBase64(frame);
       if (__result.hasError()) [[unlikely]] {
@@ -98,14 +88,6 @@ namespace margelo::nitro::yolo {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
-      auto __result = _swiftPart.detect(frame);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
 
   private:
     Yolo::HybridYoloSpec_cxx _swiftPart;