react-native-candle 1.0.1 → 19.0.7-beta

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

@@ -0,0 +1,70 @@
+///
+/// JFiatAssetQuoteRequest.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 "FiatAssetQuoteRequest.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FiatAssetQuoteRequest" and the the Kotlin data class "FiatAssetQuoteRequest".
+   */
+  struct JFiatAssetQuoteRequest final: public jni::JavaClass<JFiatAssetQuoteRequest> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/FiatAssetQuoteRequest;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FiatAssetQuoteRequest by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FiatAssetQuoteRequest toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAssetKind = clazz->getField<jni::JString>("assetKind");
+      jni::local_ref<jni::JString> assetKind = this->getFieldValue(fieldAssetKind);
+      static const auto fieldServiceAccountID = clazz->getField<jni::JString>("serviceAccountID");
+      jni::local_ref<jni::JString> serviceAccountID = this->getFieldValue(fieldServiceAccountID);
+      static const auto fieldCurrencyCode = clazz->getField<jni::JString>("currencyCode");
+      jni::local_ref<jni::JString> currencyCode = this->getFieldValue(fieldCurrencyCode);
+      static const auto fieldAmount = clazz->getField<jni::JDouble>("amount");
+      jni::local_ref<jni::JDouble> amount = this->getFieldValue(fieldAmount);
+      return FiatAssetQuoteRequest(
+        assetKind->toStdString(),
+        serviceAccountID != nullptr ? std::make_optional(serviceAccountID->toStdString()) : std::nullopt,
+        currencyCode != nullptr ? std::make_optional(currencyCode->toStdString()) : std::nullopt,
+        amount != nullptr ? std::make_optional(amount->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFiatAssetQuoteRequest::javaobject> fromCpp(const FiatAssetQuoteRequest& value) {
+      using JSignature = JFiatAssetQuoteRequest(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.assetKind),
+        value.serviceAccountID.has_value() ? jni::make_jstring(value.serviceAccountID.value()) : nullptr,
+        value.currencyCode.has_value() ? jni::make_jstring(value.currencyCode.value()) : nullptr,
+        value.amount.has_value() ? jni::JDouble::valueOf(value.amount.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,66 @@
+///
+/// JFiatAssetRef.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 "FiatAssetRef.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FiatAssetRef" and the the Kotlin data class "FiatAssetRef".
+   */
+  struct JFiatAssetRef final: public jni::JavaClass<JFiatAssetRef> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/FiatAssetRef;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FiatAssetRef by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FiatAssetRef toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAssetKind = clazz->getField<jni::JString>("assetKind");
+      jni::local_ref<jni::JString> assetKind = this->getFieldValue(fieldAssetKind);
+      static const auto fieldServiceTradeID = clazz->getField<jni::JString>("serviceTradeID");
+      jni::local_ref<jni::JString> serviceTradeID = this->getFieldValue(fieldServiceTradeID);
+      static const auto fieldLinkedAccountID = clazz->getField<jni::JString>("linkedAccountID");
+      jni::local_ref<jni::JString> linkedAccountID = this->getFieldValue(fieldLinkedAccountID);
+      return FiatAssetRef(
+        assetKind->toStdString(),
+        serviceTradeID != nullptr ? std::make_optional(serviceTradeID->toStdString()) : std::nullopt,
+        linkedAccountID->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFiatAssetRef::javaobject> fromCpp(const FiatAssetRef& value) {
+      using JSignature = JFiatAssetRef(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.assetKind),
+        value.serviceTradeID.has_value() ? jni::make_jstring(value.serviceTradeID.value()) : nullptr,
+        jni::make_jstring(value.linkedAccountID)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,67 @@
+///
+/// JFinancialAccountKind.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 "FinancialAccountKind.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "FinancialAccountKind" and the the Kotlin enum "FinancialAccountKind".
+   */
+  struct JFinancialAccountKind final: public jni::JavaClass<JFinancialAccountKind> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/FinancialAccountKind;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum FinancialAccountKind.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FinancialAccountKind toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<FinancialAccountKind>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JFinancialAccountKind> fromCpp(FinancialAccountKind value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case FinancialAccountKind::INDIVIDUAL:
+          static const auto fieldINDIVIDUAL = clazz->getStaticField<JFinancialAccountKind>("INDIVIDUAL");
+          return clazz->getStaticFieldValue(fieldINDIVIDUAL);
+        case FinancialAccountKind::JOINT:
+          static const auto fieldJOINT = clazz->getStaticField<JFinancialAccountKind>("JOINT");
+          return clazz->getStaticFieldValue(fieldJOINT);
+        case FinancialAccountKind::TRADITIONALIRA:
+          static const auto fieldTRADITIONALIRA = clazz->getStaticField<JFinancialAccountKind>("TRADITIONALIRA");
+          return clazz->getStaticFieldValue(fieldTRADITIONALIRA);
+        case FinancialAccountKind::ROTHIRA:
+          static const auto fieldROTHIRA = clazz->getStaticField<JFinancialAccountKind>("ROTHIRA");
+          return clazz->getStaticFieldValue(fieldROTHIRA);
+        case FinancialAccountKind::BUSINESS:
+          static const auto fieldBUSINESS = clazz->getStaticField<JFinancialAccountKind>("BUSINESS");
+          return clazz->getStaticFieldValue(fieldBUSINESS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,89 @@
+///
+/// JFunc_void_LinkedAccount.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 "LinkedAccount.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JLinkedAccount.hpp"
+#include <string>
+#include "Service.hpp"
+#include "JService.hpp"
+#include "LinkedAccountDetails.hpp"
+#include "JLinkedAccountDetails.hpp"
+#include "ActiveLinkedAccountDetails.hpp"
+#include <optional>
+#include "JActiveLinkedAccountDetails.hpp"
+#include "InactiveLinkedAccountDetails.hpp"
+#include "JInactiveLinkedAccountDetails.hpp"
+#include "UnavailableLinkedAccountDetails.hpp"
+#include "JUnavailableLinkedAccountDetails.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(account: LinkedAccount) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_LinkedAccount: public jni::JavaClass<JFunc_void_LinkedAccount> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Func_void_LinkedAccount;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_LinkedAccount` instance holds through JNI.
+     */
+    void invoke(const LinkedAccount& account) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLinkedAccount> /* account */)>("invoke");
+      method(self(), JLinkedAccount::fromCpp(account));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_LinkedAccount that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_LinkedAccount_cxx final: public jni::HybridClass<JFunc_void_LinkedAccount_cxx, JFunc_void_LinkedAccount> {
+  public:
+    static jni::local_ref<JFunc_void_LinkedAccount::javaobject> fromCpp(const std::function<void(const LinkedAccount& /* account */)>& func) {
+      return JFunc_void_LinkedAccount_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_LinkedAccount_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JLinkedAccount> account) {
+      _func(account->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const LinkedAccount& /* account */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Func_void_LinkedAccount_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_LinkedAccount_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_LinkedAccount_cxx(const std::function<void(const LinkedAccount& /* account */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const LinkedAccount& /* account */)> _func;
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,115 @@
+///
+/// JFunc_void_TradeExecutionResult.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 "TradeExecutionResult.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTradeExecutionResult.hpp"
+#include "Trade.hpp"
+#include <optional>
+#include "JTrade.hpp"
+#include <string>
+#include "TradeState.hpp"
+#include "JTradeState.hpp"
+#include "Counterparty.hpp"
+#include "JCounterparty.hpp"
+#include "MerchantCounterparty.hpp"
+#include "JMerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "JMerchantLocation.hpp"
+#include "UserCounterparty.hpp"
+#include "JUserCounterparty.hpp"
+#include "ServiceCounterparty.hpp"
+#include "JServiceCounterparty.hpp"
+#include "Service.hpp"
+#include "JService.hpp"
+#include "TradeAsset.hpp"
+#include "JTradeAsset.hpp"
+#include "FiatAsset.hpp"
+#include "JFiatAsset.hpp"
+#include "CryptoAsset.hpp"
+#include "JCryptoAsset.hpp"
+#include "StockAsset.hpp"
+#include "JStockAsset.hpp"
+#include "TransportAsset.hpp"
+#include "JTransportAsset.hpp"
+#include "Coordinates.hpp"
+#include "JCoordinates.hpp"
+#include "Address.hpp"
+#include "JAddress.hpp"
+#include "EventAsset.hpp"
+#include "JEventAsset.hpp"
+#include "OtherAsset.hpp"
+#include "JOtherAsset.hpp"
+#include "NothingAsset.hpp"
+#include "JNothingAsset.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(result: TradeExecutionResult) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_TradeExecutionResult: public jni::JavaClass<JFunc_void_TradeExecutionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Func_void_TradeExecutionResult;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_TradeExecutionResult` instance holds through JNI.
+     */
+    void invoke(const TradeExecutionResult& result) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTradeExecutionResult> /* result */)>("invoke");
+      method(self(), JTradeExecutionResult::fromCpp(result));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_TradeExecutionResult that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_TradeExecutionResult_cxx final: public jni::HybridClass<JFunc_void_TradeExecutionResult_cxx, JFunc_void_TradeExecutionResult> {
+  public:
+    static jni::local_ref<JFunc_void_TradeExecutionResult::javaobject> fromCpp(const std::function<void(const TradeExecutionResult& /* result */)>& func) {
+      return JFunc_void_TradeExecutionResult_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_TradeExecutionResult_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTradeExecutionResult> result) {
+      _func(result->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const TradeExecutionResult& /* result */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Func_void_TradeExecutionResult_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_TradeExecutionResult_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_TradeExecutionResult_cxx(const std::function<void(const TradeExecutionResult& /* result */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const TradeExecutionResult& /* result */)> _func;
+  };
+
+} // namespace margelo::nitro::rncandle