react-native-nitro-pose-exercises 1.0.2

package/nitrogen/generated/ios/NitroPoseExercisesAutolinking.mm

@@ -0,0 +1,33 @@
+///
+/// NitroPoseExercisesAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroPoseExercises-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridNitroPoseExercisesSpecSwift.hpp"
+
+@interface NitroPoseExercisesAutolinking : NSObject
+@end
+
+@implementation NitroPoseExercisesAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitroposeexercises;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroPoseExercises",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridNitroPoseExercisesSpec> hybridObject = NitroPoseExercises::NitroPoseExercisesAutolinking::createNitroPoseExercises();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroPoseExercisesAutolinking.swift

@@ -0,0 +1,26 @@
+///
+/// NitroPoseExercisesAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroPoseExercisesAutolinking {
+  public typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  public static func createNitroPoseExercises() -> bridge.std__shared_ptr_HybridNitroPoseExercisesSpec_ {
+    let hybridObject = NitroPoseExercises()
+    return { () -> bridge.std__shared_ptr_HybridNitroPoseExercisesSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isNitroPoseExercisesRecyclable() -> Bool {
+    return NitroPoseExercises.self is any RecyclableView.Type
+  }
+}

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

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

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

@@ -0,0 +1,236 @@
+///
+/// HybridNitroPoseExercisesSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroPoseExercisesSpec.hpp"
+
+// Forward declaration of `HybridNitroPoseExercisesSpec_cxx` to properly resolve imports.
+namespace NitroPoseExercises { class HybridNitroPoseExercisesSpec_cxx; }
+
+// Forward declaration of `SessionStatus` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class SessionStatus; }
+// Forward declaration of `RepData` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct RepData; }
+// Forward declaration of `AngleSnapshot` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct AngleSnapshot; }
+// Forward declaration of `ExercisePhase` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class ExercisePhase; }
+// Forward declaration of `FormFeedback` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct FormFeedback; }
+// Forward declaration of `FormSeverity` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class FormSeverity; }
+// Forward declaration of `HoldProgress` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct HoldProgress; }
+// Forward declaration of `SessionResult` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct SessionResult; }
+// Forward declaration of `Landmark` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct Landmark; }
+// Forward declaration of `ExerciseConfig` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct ExerciseConfig; }
+// Forward declaration of `ExerciseType` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class ExerciseType; }
+// Forward declaration of `AngleDefinition` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct AngleDefinition; }
+// Forward declaration of `PhaseThreshold` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct PhaseThreshold; }
+// Forward declaration of `FormRule` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct FormRule; }
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
+
+#include "SessionStatus.hpp"
+#include "RepData.hpp"
+#include <functional>
+#include <optional>
+#include "AngleSnapshot.hpp"
+#include <vector>
+#include <string>
+#include "ExercisePhase.hpp"
+#include "FormFeedback.hpp"
+#include "FormSeverity.hpp"
+#include "HoldProgress.hpp"
+#include "SessionResult.hpp"
+#include "Landmark.hpp"
+#include <NitroModules/Promise.hpp>
+#include "ExerciseConfig.hpp"
+#include "ExerciseType.hpp"
+#include "AngleDefinition.hpp"
+#include "PhaseThreshold.hpp"
+#include "FormRule.hpp"
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+
+#include "NitroPoseExercises-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  /**
+   * The C++ part of HybridNitroPoseExercisesSpec_cxx.swift.
+   *
+   * HybridNitroPoseExercisesSpecSwift (C++) accesses HybridNitroPoseExercisesSpec_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, HybridNitroPoseExercisesSpec_cxx can directly inherit from the C++ class HybridNitroPoseExercisesSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroPoseExercisesSpecSwift: public virtual HybridNitroPoseExercisesSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroPoseExercisesSpecSwift(const NitroPoseExercises::HybridNitroPoseExercisesSpec_cxx& swiftPart):
+      HybridObject(HybridNitroPoseExercisesSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPoseExercises::HybridNitroPoseExercisesSpec_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<HybridNitroPoseExercisesSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline SessionStatus getStatus() noexcept override {
+      auto __result = _swiftPart.getStatus();
+      return static_cast<SessionStatus>(__result);
+    }
+    inline std::optional<std::function<void(const RepData& /* data */)>> getOnRepComplete() noexcept override {
+      auto __result = _swiftPart.getOnRepComplete();
+      return __result;
+    }
+    inline void setOnRepComplete(const std::optional<std::function<void(const RepData& /* data */)>>& onRepComplete) noexcept override {
+      _swiftPart.setOnRepComplete(onRepComplete);
+    }
+    inline std::optional<std::function<void(ExercisePhase /* phase */)>> getOnPhaseChange() noexcept override {
+      auto __result = _swiftPart.getOnPhaseChange();
+      return __result;
+    }
+    inline void setOnPhaseChange(const std::optional<std::function<void(ExercisePhase /* phase */)>>& onPhaseChange) noexcept override {
+      _swiftPart.setOnPhaseChange(onPhaseChange);
+    }
+    inline std::optional<std::function<void(const FormFeedback& /* feedback */)>> getOnFormFeedback() noexcept override {
+      auto __result = _swiftPart.getOnFormFeedback();
+      return __result;
+    }
+    inline void setOnFormFeedback(const std::optional<std::function<void(const FormFeedback& /* feedback */)>>& onFormFeedback) noexcept override {
+      _swiftPart.setOnFormFeedback(onFormFeedback);
+    }
+    inline std::optional<std::function<void(const HoldProgress& /* progress */)>> getOnHoldProgress() noexcept override {
+      auto __result = _swiftPart.getOnHoldProgress();
+      return __result;
+    }
+    inline void setOnHoldProgress(const std::optional<std::function<void(const HoldProgress& /* progress */)>>& onHoldProgress) noexcept override {
+      _swiftPart.setOnHoldProgress(onHoldProgress);
+    }
+    inline std::optional<std::function<void()>> getOnPoseLost() noexcept override {
+      auto __result = _swiftPart.getOnPoseLost();
+      return __result;
+    }
+    inline void setOnPoseLost(const std::optional<std::function<void()>>& onPoseLost) noexcept override {
+      _swiftPart.setOnPoseLost(onPoseLost);
+    }
+    inline std::optional<std::function<void()>> getOnPoseRegained() noexcept override {
+      auto __result = _swiftPart.getOnPoseRegained();
+      return __result;
+    }
+    inline void setOnPoseRegained(const std::optional<std::function<void()>>& onPoseRegained) noexcept override {
+      _swiftPart.setOnPoseRegained(onPoseRegained);
+    }
+    inline std::optional<std::function<void(const SessionResult& /* result */)>> getOnSessionComplete() noexcept override {
+      auto __result = _swiftPart.getOnSessionComplete();
+      return __result;
+    }
+    inline void setOnSessionComplete(const std::optional<std::function<void(const SessionResult& /* result */)>>& onSessionComplete) noexcept override {
+      _swiftPart.setOnSessionComplete(onSessionComplete);
+    }
+    inline ExercisePhase getCurrentPhase() noexcept override {
+      auto __result = _swiftPart.getCurrentPhase();
+      return static_cast<ExercisePhase>(__result);
+    }
+    inline double getRepCount() noexcept override {
+      return _swiftPart.getRepCount();
+    }
+    inline std::vector<Landmark> getLandmarks() noexcept override {
+      auto __result = _swiftPart.getLandmarks();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> initialize(const std::string& modelPath) override {
+      auto __result = _swiftPart.initialize(modelPath);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void release() override {
+      auto __result = _swiftPart.release();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void loadExercise(const ExerciseConfig& config) override {
+      auto __result = _swiftPart.loadExercise(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void processFrame(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
+      auto __result = _swiftPart.processFrame(frame);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void startSession(double targetReps, double countdownSeconds) override {
+      auto __result = _swiftPart.startSession(std::forward<decltype(targetReps)>(targetReps), std::forward<decltype(countdownSeconds)>(countdownSeconds));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void pauseSession() override {
+      auto __result = _swiftPart.pauseSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void resumeSession() override {
+      auto __result = _swiftPart.resumeSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stopSession() override {
+      auto __result = _swiftPart.stopSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroPoseExercises::HybridNitroPoseExercisesSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

package/nitrogen/generated/ios/swift/AngleDefinition.swift

@@ -0,0 +1,44 @@
+///
+/// AngleDefinition.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `AngleDefinition`, backed by a C++ struct.
+ */
+public typealias AngleDefinition = margelo.nitro.nitroposeexercises.AngleDefinition
+
+public extension AngleDefinition {
+  private typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  /**
+   * Create a new instance of `AngleDefinition`.
+   */
+  init(name: String, landmarkA: Double, landmarkB: Double, landmarkC: Double) {
+    self.init(std.string(name), landmarkA, landmarkB, landmarkC)
+  }
+
+  @inline(__always)
+  var name: String {
+    return String(self.__name)
+  }
+  
+  @inline(__always)
+  var landmarkA: Double {
+    return self.__landmarkA
+  }
+  
+  @inline(__always)
+  var landmarkB: Double {
+    return self.__landmarkB
+  }
+  
+  @inline(__always)
+  var landmarkC: Double {
+    return self.__landmarkC
+  }
+}

package/nitrogen/generated/ios/swift/AngleSnapshot.swift

@@ -0,0 +1,34 @@
+///
+/// AngleSnapshot.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `AngleSnapshot`, backed by a C++ struct.
+ */
+public typealias AngleSnapshot = margelo.nitro.nitroposeexercises.AngleSnapshot
+
+public extension AngleSnapshot {
+  private typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  /**
+   * Create a new instance of `AngleSnapshot`.
+   */
+  init(name: String, value: Double) {
+    self.init(std.string(name), value)
+  }
+
+  @inline(__always)
+  var name: String {
+    return String(self.__name)
+  }
+  
+  @inline(__always)
+  var value: Double {
+    return self.__value
+  }
+}

package/nitrogen/generated/ios/swift/ExerciseConfig.swift

@@ -0,0 +1,83 @@
+///
+/// ExerciseConfig.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ExerciseConfig`, backed by a C++ struct.
+ */
+public typealias ExerciseConfig = margelo.nitro.nitroposeexercises.ExerciseConfig
+
+public extension ExerciseConfig {
+  private typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  /**
+   * Create a new instance of `ExerciseConfig`.
+   */
+  init(name: String, type: ExerciseType, angles: [AngleDefinition], phases: [PhaseThreshold], repSequence: [ExercisePhase], formRules: [FormRule], holdDurationMs: Double) {
+    self.init(std.string(name), type, { () -> bridge.std__vector_AngleDefinition_ in
+      var __vector = bridge.create_std__vector_AngleDefinition_(angles.count)
+      for __item in angles {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), { () -> bridge.std__vector_PhaseThreshold_ in
+      var __vector = bridge.create_std__vector_PhaseThreshold_(phases.count)
+      for __item in phases {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), { () -> bridge.std__vector_ExercisePhase_ in
+      var __vector = bridge.create_std__vector_ExercisePhase_(repSequence.count)
+      for __item in repSequence {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), { () -> bridge.std__vector_FormRule_ in
+      var __vector = bridge.create_std__vector_FormRule_(formRules.count)
+      for __item in formRules {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), holdDurationMs)
+  }
+
+  @inline(__always)
+  var name: String {
+    return String(self.__name)
+  }
+  
+  @inline(__always)
+  var type: ExerciseType {
+    return self.__type
+  }
+  
+  @inline(__always)
+  var angles: [AngleDefinition] {
+    return self.__angles.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var phases: [PhaseThreshold] {
+    return self.__phases.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var repSequence: [ExercisePhase] {
+    return self.__repSequence.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var formRules: [FormRule] {
+    return self.__formRules.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var holdDurationMs: Double {
+    return self.__holdDurationMs
+  }
+}

package/nitrogen/generated/ios/swift/ExercisePhase.swift

@@ -0,0 +1,52 @@
+///
+/// ExercisePhase.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `ExercisePhase`, backed by a C++ enum.
+ */
+public typealias ExercisePhase = margelo.nitro.nitroposeexercises.ExercisePhase
+
+public extension ExercisePhase {
+  /**
+   * Get a ExercisePhase for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "hold":
+        self = .hold
+      case "up":
+        self = .up
+      case "down":
+        self = .down
+      case "transition":
+        self = .transition
+      case "unknown":
+        self = .unknown
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ExercisePhase represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .hold:
+        return "hold"
+      case .up:
+        return "up"
+      case .down:
+        return "down"
+      case .transition:
+        return "transition"
+      case .unknown:
+        return "unknown"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ExerciseType.swift

@@ -0,0 +1,44 @@
+///
+/// ExerciseType.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `ExerciseType`, backed by a C++ enum.
+ */
+public typealias ExerciseType = margelo.nitro.nitroposeexercises.ExerciseType
+
+public extension ExerciseType {
+  /**
+   * Get a ExerciseType for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "rep":
+        self = .rep
+      case "hold":
+        self = .hold
+      case "flow":
+        self = .flow
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ExerciseType represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .rep:
+        return "rep"
+      case .hold:
+        return "hold"
+      case .flow:
+        return "flow"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/FormFeedback.swift

@@ -0,0 +1,39 @@
+///
+/// FormFeedback.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `FormFeedback`, backed by a C++ struct.
+ */
+public typealias FormFeedback = margelo.nitro.nitroposeexercises.FormFeedback
+
+public extension FormFeedback {
+  private typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  /**
+   * Create a new instance of `FormFeedback`.
+   */
+  init(ruleName: String, message: String, severity: FormSeverity) {
+    self.init(std.string(ruleName), std.string(message), severity)
+  }
+
+  @inline(__always)
+  var ruleName: String {
+    return String(self.__ruleName)
+  }
+  
+  @inline(__always)
+  var message: String {
+    return String(self.__message)
+  }
+  
+  @inline(__always)
+  var severity: FormSeverity {
+    return self.__severity
+  }
+}

package/nitrogen/generated/ios/swift/FormRule.swift

@@ -0,0 +1,54 @@
+///
+/// FormRule.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `FormRule`, backed by a C++ struct.
+ */
+public typealias FormRule = margelo.nitro.nitroposeexercises.FormRule
+
+public extension FormRule {
+  private typealias bridge = margelo.nitro.nitroposeexercises.bridge.swift
+
+  /**
+   * Create a new instance of `FormRule`.
+   */
+  init(name: String, message: String, severity: FormSeverity, angleName: String, minAngle: Double, maxAngle: Double) {
+    self.init(std.string(name), std.string(message), severity, std.string(angleName), minAngle, maxAngle)
+  }
+
+  @inline(__always)
+  var name: String {
+    return String(self.__name)
+  }
+  
+  @inline(__always)
+  var message: String {
+    return String(self.__message)
+  }
+  
+  @inline(__always)
+  var severity: FormSeverity {
+    return self.__severity
+  }
+  
+  @inline(__always)
+  var angleName: String {
+    return String(self.__angleName)
+  }
+  
+  @inline(__always)
+  var minAngle: Double {
+    return self.__minAngle
+  }
+  
+  @inline(__always)
+  var maxAngle: Double {
+    return self.__maxAngle
+  }
+}