react-native-nitro-pose-exercises 1.0.2

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

@@ -0,0 +1,79 @@
+///
+/// JFormRule.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "FormRule.hpp"
+
+#include "FormSeverity.hpp"
+#include "JFormSeverity.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FormRule" and the the Kotlin data class "FormRule".
+   */
+  struct JFormRule final: public jni::JavaClass<JFormRule> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/FormRule;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FormRule by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FormRule toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      static const auto fieldSeverity = clazz->getField<JFormSeverity>("severity");
+      jni::local_ref<JFormSeverity> severity = this->getFieldValue(fieldSeverity);
+      static const auto fieldAngleName = clazz->getField<jni::JString>("angleName");
+      jni::local_ref<jni::JString> angleName = this->getFieldValue(fieldAngleName);
+      static const auto fieldMinAngle = clazz->getField<double>("minAngle");
+      double minAngle = this->getFieldValue(fieldMinAngle);
+      static const auto fieldMaxAngle = clazz->getField<double>("maxAngle");
+      double maxAngle = this->getFieldValue(fieldMaxAngle);
+      return FormRule(
+        name->toStdString(),
+        message->toStdString(),
+        severity->toCpp(),
+        angleName->toStdString(),
+        minAngle,
+        maxAngle
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFormRule::javaobject> fromCpp(const FormRule& value) {
+      using JSignature = JFormRule(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JFormSeverity>, jni::alias_ref<jni::JString>, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        jni::make_jstring(value.message),
+        JFormSeverity::fromCpp(value.severity),
+        jni::make_jstring(value.angleName),
+        value.minAngle,
+        value.maxAngle
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,61 @@
+///
+/// JFormSeverity.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "FormSeverity.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "FormSeverity" and the the Kotlin enum "FormSeverity".
+   */
+  struct JFormSeverity final: public jni::JavaClass<JFormSeverity> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/FormSeverity;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum FormSeverity.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FormSeverity toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<FormSeverity>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JFormSeverity> fromCpp(FormSeverity value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case FormSeverity::INFO:
+          static const auto fieldINFO = clazz->getStaticField<JFormSeverity>("INFO");
+          return clazz->getStaticFieldValue(fieldINFO);
+        case FormSeverity::WARNING:
+          static const auto fieldWARNING = clazz->getStaticField<JFormSeverity>("WARNING");
+          return clazz->getStaticFieldValue(fieldWARNING);
+        case FormSeverity::ERROR:
+          static const auto fieldERROR = clazz->getStaticField<JFormSeverity>("ERROR");
+          return clazz->getStaticFieldValue(fieldERROR);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_ExercisePhase.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ExercisePhase.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JExercisePhase.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(phase: ExercisePhase) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ExercisePhase: public jni::JavaClass<JFunc_void_ExercisePhase> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_ExercisePhase;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ExercisePhase` instance holds through JNI.
+     */
+    void invoke(ExercisePhase phase) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JExercisePhase> /* phase */)>("invoke");
+      method(self(), JExercisePhase::fromCpp(phase));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ExercisePhase that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_ExercisePhase_cxx final: public jni::HybridClass<JFunc_void_ExercisePhase_cxx, JFunc_void_ExercisePhase> {
+  public:
+    static jni::local_ref<JFunc_void_ExercisePhase::javaobject> fromCpp(const std::function<void(ExercisePhase /* phase */)>& func) {
+      return JFunc_void_ExercisePhase_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ExercisePhase_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JExercisePhase> phase) {
+      _func(phase->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(ExercisePhase /* phase */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_ExercisePhase_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ExercisePhase_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ExercisePhase_cxx(const std::function<void(ExercisePhase /* phase */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(ExercisePhase /* phase */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_FormFeedback.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "FormFeedback.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JFormFeedback.hpp"
+#include <string>
+#include "FormSeverity.hpp"
+#include "JFormSeverity.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(feedback: FormFeedback) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_FormFeedback: public jni::JavaClass<JFunc_void_FormFeedback> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_FormFeedback;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_FormFeedback` instance holds through JNI.
+     */
+    void invoke(const FormFeedback& feedback) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFormFeedback> /* feedback */)>("invoke");
+      method(self(), JFormFeedback::fromCpp(feedback));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_FormFeedback that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_FormFeedback_cxx final: public jni::HybridClass<JFunc_void_FormFeedback_cxx, JFunc_void_FormFeedback> {
+  public:
+    static jni::local_ref<JFunc_void_FormFeedback::javaobject> fromCpp(const std::function<void(const FormFeedback& /* feedback */)>& func) {
+      return JFunc_void_FormFeedback_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_FormFeedback_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JFormFeedback> feedback) {
+      _func(feedback->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const FormFeedback& /* feedback */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_FormFeedback_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_FormFeedback_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_FormFeedback_cxx(const std::function<void(const FormFeedback& /* feedback */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const FormFeedback& /* feedback */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_HoldProgress.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "HoldProgress.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JHoldProgress.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(progress: HoldProgress) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_HoldProgress: public jni::JavaClass<JFunc_void_HoldProgress> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_HoldProgress;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_HoldProgress` instance holds through JNI.
+     */
+    void invoke(const HoldProgress& progress) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHoldProgress> /* progress */)>("invoke");
+      method(self(), JHoldProgress::fromCpp(progress));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_HoldProgress that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_HoldProgress_cxx final: public jni::HybridClass<JFunc_void_HoldProgress_cxx, JFunc_void_HoldProgress> {
+  public:
+    static jni::local_ref<JFunc_void_HoldProgress::javaobject> fromCpp(const std::function<void(const HoldProgress& /* progress */)>& func) {
+      return JFunc_void_HoldProgress_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_HoldProgress_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JHoldProgress> progress) {
+      _func(progress->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const HoldProgress& /* progress */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_HoldProgress_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_HoldProgress_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_HoldProgress_cxx(const std::function<void(const HoldProgress& /* progress */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const HoldProgress& /* progress */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,81 @@
+///
+/// JFunc_void_RepData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "RepData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JRepData.hpp"
+#include "AngleSnapshot.hpp"
+#include <vector>
+#include "JAngleSnapshot.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: RepData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_RepData: public jni::JavaClass<JFunc_void_RepData> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_RepData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_RepData` instance holds through JNI.
+     */
+    void invoke(const RepData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRepData> /* data */)>("invoke");
+      method(self(), JRepData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_RepData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_RepData_cxx final: public jni::HybridClass<JFunc_void_RepData_cxx, JFunc_void_RepData> {
+  public:
+    static jni::local_ref<JFunc_void_RepData::javaobject> fromCpp(const std::function<void(const RepData& /* data */)>& func) {
+      return JFunc_void_RepData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_RepData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JRepData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const RepData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_RepData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_RepData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_RepData_cxx(const std::function<void(const RepData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const RepData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,85 @@
+///
+/// JFunc_void_SessionResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "SessionResult.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JSessionResult.hpp"
+#include "FormFeedback.hpp"
+#include <vector>
+#include "JFormFeedback.hpp"
+#include <string>
+#include "FormSeverity.hpp"
+#include "JFormSeverity.hpp"
+#include "AngleSnapshot.hpp"
+#include "JAngleSnapshot.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(result: SessionResult) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_SessionResult: public jni::JavaClass<JFunc_void_SessionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_SessionResult;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_SessionResult` instance holds through JNI.
+     */
+    void invoke(const SessionResult& result) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSessionResult> /* result */)>("invoke");
+      method(self(), JSessionResult::fromCpp(result));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_SessionResult that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_SessionResult_cxx final: public jni::HybridClass<JFunc_void_SessionResult_cxx, JFunc_void_SessionResult> {
+  public:
+    static jni::local_ref<JFunc_void_SessionResult::javaobject> fromCpp(const std::function<void(const SessionResult& /* result */)>& func) {
+      return JFunc_void_SessionResult_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_SessionResult_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JSessionResult> result) {
+      _func(result->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const SessionResult& /* result */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Func_void_SessionResult_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_SessionResult_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_SessionResult_cxx(const std::function<void(const SessionResult& /* result */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const SessionResult& /* result */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,65 @@
+///
+/// JHoldProgress.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HoldProgress.hpp"
+
+
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HoldProgress" and the the Kotlin data class "HoldProgress".
+   */
+  struct JHoldProgress final: public jni::JavaClass<JHoldProgress> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/HoldProgress;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HoldProgress by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HoldProgress toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldElapsedMs = clazz->getField<double>("elapsedMs");
+      double elapsedMs = this->getFieldValue(fieldElapsedMs);
+      static const auto fieldTargetMs = clazz->getField<double>("targetMs");
+      double targetMs = this->getFieldValue(fieldTargetMs);
+      static const auto fieldStability = clazz->getField<double>("stability");
+      double stability = this->getFieldValue(fieldStability);
+      return HoldProgress(
+        elapsedMs,
+        targetMs,
+        stability
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHoldProgress::javaobject> fromCpp(const HoldProgress& value) {
+      using JSignature = JHoldProgress(double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.elapsedMs,
+        value.targetMs,
+        value.stability
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises