react-native-yolo 0.0.5 → 0.0.8

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;

package/nitrogen/generated/ios/swift/HybridYoloModelSpec.swift

@@ -0,0 +1,57 @@
+///
+/// HybridYoloModelSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import VisionCamera
+import NitroModules
+
+/// See ``HybridYoloModelSpec``
+public protocol HybridYoloModelSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func detect(frame: (any HybridFrameSpec)) throws -> [Detection]
+  func close() throws -> Void
+}
+
+public extension HybridYoloModelSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject YoloModel]"
+  }
+}
+
+/// See ``HybridYoloModelSpec``
+open class HybridYoloModelSpec_base {
+  private weak var cxxWrapper: HybridYoloModelSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridYoloModelSpec_cxx {
+  #if DEBUG
+    guard self is any HybridYoloModelSpec else {
+      fatalError("`self` is not a `HybridYoloModelSpec`! Did you accidentally inherit from `HybridYoloModelSpec_base` instead of `HybridYoloModelSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridYoloModelSpec_cxx(self as! any HybridYoloModelSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the YoloModel HybridObject.
+ * Implement this protocol to create Swift-based instances of YoloModel.
+ * ```swift
+ * class HybridYoloModel : HybridYoloModelSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridYoloModelSpec = HybridYoloModelSpec_protocol & HybridYoloModelSpec_base

package/nitrogen/generated/ios/swift/HybridYoloModelSpec_cxx.swift

@@ -0,0 +1,160 @@
+///
+/// HybridYoloModelSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+import VisionCamera
+
+/**
+ * A class implementation that bridges HybridYoloModelSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridYoloModelSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::yolo::bridge::swift`)
+   * from `Yolo-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.yolo.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridYoloModelSpec` Swift protocol.
+   */
+  private var __implementation: any HybridYoloModelSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridYoloModelSpec_
+
+  /**
+   * Create a new `HybridYoloModelSpec_cxx` that wraps the given `HybridYoloModelSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridYoloModelSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridYoloModelSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridYoloModelSpec() -> any HybridYoloModelSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridYoloModelSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridYoloModelSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridYoloModelSpec_cxx {
+    return Unmanaged<HybridYoloModelSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridYoloModelSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridYoloModelSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridYoloModelSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridYoloModelSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridYoloModelSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func detect(frame: bridge.std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_) -> bridge.Result_std__vector_Detection__ {
+    do {
+      let __result = try self.__implementation.detect(frame: { () -> any HybridFrameSpec in
+        let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(frame)
+        let __instance = HybridFrameSpec_cxx.fromUnsafe(__unsafePointer)
+        return __instance.getHybridFrameSpec()
+      }())
+      let __resultCpp = { () -> bridge.std__vector_Detection_ in
+        var __vector = bridge.create_std__vector_Detection_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_Detection__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Detection__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func close() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.close()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/HybridYoloSpec.swift

@@ -14,10 +14,8 @@ public protocol HybridYoloSpec_protocol: HybridObject {
   
 
   // Methods
-  func sum(num1: Double, num2: Double) throws -> Double
-  func loadModel(modelPath: String) throws -> Void
+  func loadModel(modelPath: String) throws -> (any HybridYoloModelSpec)
   func frameToBase64(frame: (any HybridFrameSpec)) throws -> String
-  func detect(frame: (any HybridFrameSpec)) throws -> [Detection]
 }
 
 public extension HybridYoloSpec_protocol {

package/nitrogen/generated/ios/swift/HybridYoloSpec_cxx.swift

@@ -126,25 +126,17 @@ open class HybridYoloSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func sum(num1: Double, num2: Double) -> bridge.Result_double_ {
+  public final func loadModel(modelPath: std.string) -> bridge.Result_std__shared_ptr_HybridYoloModelSpec__ {
     do {
-      let __result = try self.__implementation.sum(num1: num1, num2: num2)
-      let __resultCpp = __result
-      return bridge.create_Result_double_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_double_(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func loadModel(modelPath: std.string) -> bridge.Result_void_ {
-    do {
-      try self.__implementation.loadModel(modelPath: String(modelPath))
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.loadModel(modelPath: String(modelPath))
+      let __resultCpp = { () -> bridge.std__shared_ptr_HybridYoloModelSpec_ in
+        let __cxxWrapped = __result.getCxxWrapper()
+        return __cxxWrapped.getCxxPart()
+      }()
+      return bridge.create_Result_std__shared_ptr_HybridYoloModelSpec__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_HybridYoloModelSpec__(__exceptionPtr)
     }
   }
   
@@ -163,26 +155,4 @@ open class HybridYoloSpec_cxx {
       return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
-  
-  @inline(__always)
-  public final func detect(frame: bridge.std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_) -> bridge.Result_std__vector_Detection__ {
-    do {
-      let __result = try self.__implementation.detect(frame: { () -> any HybridFrameSpec in
-        let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(frame)
-        let __instance = HybridFrameSpec_cxx.fromUnsafe(__unsafePointer)
-        return __instance.getHybridFrameSpec()
-      }())
-      let __resultCpp = { () -> bridge.std__vector_Detection_ in
-        var __vector = bridge.create_std__vector_Detection_(__result.count)
-        for __item in __result {
-          __vector.push_back(__item)
-        }
-        return __vector
-      }()
-      return bridge.create_Result_std__vector_Detection__(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__vector_Detection__(__exceptionPtr)
-    }
-  }
 }

package/nitrogen/generated/shared/c++/HybridYoloModelSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridYoloModelSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridYoloModelSpec.hpp"
+
+namespace margelo::nitro::yolo {
+
+  void HybridYoloModelSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("detect", &HybridYoloModelSpec::detect);
+      prototype.registerHybridMethod("close", &HybridYoloModelSpec::close);
+    });
+  }
+
+} // namespace margelo::nitro::yolo