diff --git a/docs/docs/errors.md b/docs/docs/errors.md index f2d554684..ba5c3cefd 100644 --- a/docs/docs/errors.md +++ b/docs/docs/errors.md @@ -113,8 +113,3 @@ try { console.log(error) } ``` - -## Swift Errors - -Due to a Swift compiler bug, Swift Hybrid Objects can currently not throw errors. Instead, they will raise a `fatalError(..)` which can only be seen if the app is running in Xcode (debugger). -This should be fixed in the next Xcode version. diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock index 4d9556b45..c73f2e2c5 100644 --- a/example/ios/Podfile.lock +++ b/example/ios/Podfile.lock @@ -1895,7 +1895,7 @@ SPEC CHECKSUMS: glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a hermes-engine: 06a9c6900587420b90accc394199527c64259db4 NitroImage: df6e7bc6d5cc2be5d3c47aec9e88d2af8498da88 - NitroModules: d5e3886c34fc5c5ebab18327e52f35460c039e2d + NitroModules: bc157840c2fbc711c282025d3964b16d857cb9eb RCT-Folly: bf5c0376ffe4dd2cf438dcf86db385df9fdce648 RCTDeprecation: fb7d408617e25d7f537940000d766d60149c5fea RCTRequired: 9aaf0ffcc1f41f0c671af863970ef25c422a9920 diff --git a/example/src/getTests.ts b/example/src/getTests.ts index 9a5822c9c..45da2fb77 100644 --- a/example/src/getTests.ts +++ b/example/src/getTests.ts @@ -428,6 +428,13 @@ export function getTests( `Error: ${testObject.name}.funcThatThrows(...): This function will only work after sacrificing seven lambs!` ) ), + createTest('funcThatThrowsBeforePromise() throws', async () => + ( + await it(async () => await testObject.funcThatThrowsBeforePromise()) + ).didThrow( + `Error: ${testObject.name}.funcThatThrowsBeforePromise(...): This function will only work after sacrificing eight lambs!` + ) + ), createTest('throwError(error) throws same message from JS', () => it(() => { const error = new Error('rethrowing a JS error from native!') diff --git a/packages/nitrogen/src/syntax/createType.ts b/packages/nitrogen/src/syntax/createType.ts index f4e63a450..967c3a5b8 100644 --- a/packages/nitrogen/src/syntax/createType.ts +++ b/packages/nitrogen/src/syntax/createType.ts @@ -154,6 +154,18 @@ function getTypeId(type: TSMorphType, isOptional: boolean): string { return key } +export function addKnownType( + key: string, + type: Type, + language: Language +): void { + if (knownTypes[language].has(key)) { + // type is already known + return + } + knownTypes[language].set(key, type) +} + /** * Create a new type (or return it from cache if it is already known) */ diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts index df2644730..e335d02c3 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts @@ -103,6 +103,9 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> { case 'map': // AnyMapHolder <> AnyMap return true + case 'result-wrapper': + // Result <> T + return true default: return false } @@ -223,6 +226,7 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> { case 'variant': case 'tuple': case 'record': + case 'result-wrapper': case 'promise': { const bridge = this.getBridgeOrThrow() switch (language) { diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts index d28262c13..68e406b2c 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts @@ -18,6 +18,7 @@ import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrella import { VoidType } from '../types/VoidType.js' import { NamedWrappingType } from '../types/NamedWrappingType.js' import { ErrorType } from '../types/ErrorType.js' +import { ResultWrappingType } from '../types/ResultWrappingType.js' export interface SwiftCxxHelper { cxxHeader: { @@ -52,6 +53,10 @@ export function createSwiftCxxHelpers(type: Type): SwiftCxxHelper | undefined { return createCxxTupleSwiftHelper(getTypeAs(type, TupleType)) case 'promise': return createCxxPromiseSwiftHelper(getTypeAs(type, PromiseType)) + case 'result-wrapper': + return createCxxResultWrapperSwiftHelper( + getTypeAs(type, ResultWrappingType) + ) default: return undefined } @@ -504,6 +509,57 @@ inline ${actualType} create_${name}(${typesSignature}) { } } +/** + * Create a C++ `create_result` function that can be called from Swift to create a `Result`. + */ +function createCxxResultWrapperSwiftHelper( + type: ResultWrappingType +): SwiftCxxHelper { + const actualType = type.getCode('c++') + const name = escapeCppName(type.getCode('c++')) + const funcName = `create_${name}` + + const functions: string[] = [] + if (type.result.kind === 'void') { + functions.push( + ` +inline ${name} ${funcName}() { + return ${actualType}::withValue(); +}`.trim() + ) + } else { + const typeParam = type.result.canBePassedByReference + ? `const ${type.result.getCode('c++')}&` + : type.result.getCode('c++') + functions.push( + ` +inline ${name} ${funcName}(${typeParam} value) { + return ${actualType}::withValue(${type.result.canBePassedByReference ? 'value' : 'std::move(value)'}); +}`.trim() + ) + } + functions.push( + ` +inline ${name} ${funcName}(const ${type.error.getCode('c++')}& error) { + return ${actualType}::withError(error); +}`.trim() + ) + + return { + cxxType: actualType, + specializationName: name, + funcName: funcName, + cxxHeader: { + code: ` +using ${name} = ${actualType}; +${functions.join('\n')} + `.trim(), + requiredIncludes: type.getRequiredImports(), + }, + dependencies: [], + } +} + /** * Creates a C++ `create_promise_T()` function that can be called from Swift to create a `std::shared_ptr>`. */ diff --git a/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts b/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts index 2e6380d04..51caaa07d 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts @@ -15,6 +15,8 @@ import { NitroConfig } from '../../config/NitroConfig.js' import { includeHeader } from '../c++/includeNitroHeader.js' import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrellaHeader.js' import { HybridObjectType } from '../types/HybridObjectType.js' +import { addKnownType } from '../createType.js' +import { ResultWrappingType } from '../types/ResultWrappingType.js' export function getBridgeNamespace() { return NitroConfig.getCxxNamespace('swift', 'bridge', 'swift') @@ -231,19 +233,26 @@ return ${bridged.parseFromSwiftToCpp('__result', 'c++')}; } }) .join(', ') - const bridgedReturnType = new SwiftCxxBridgedType(m.returnType) + const bridgedReturnType = new SwiftCxxBridgedType(m.returnType, true) const hasResult = m.returnType.kind !== 'void' let body: string if (hasResult) { // func returns something body = ` auto __result = _swiftPart.${m.name}(${params}); -return ${bridgedReturnType.parseFromSwiftToCpp('__result', 'c++')}; +if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); +} +auto __value = std::move(__result.value()); +return ${bridgedReturnType.parseFromSwiftToCpp('__value', 'c++')}; `.trim() } else { // void func body = ` -_swiftPart.${m.name}(${params}); +auto __result = _swiftPart.${m.name}(${params}); +if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); +} `.trim() } @@ -419,7 +428,18 @@ public var ${property.name}: ${bridgedType.getTypeCode('swift')} { } function getMethodForwardImplementation(method: Method): string { - const returnType = new SwiftCxxBridgedType(method.returnType) + // wrapped return in a std::expected + const resultType = new ResultWrappingType(method.returnType) + addKnownType(`expected_${resultType.getCode('c++')}`, resultType, 'swift') + const bridgedResultType = new SwiftCxxBridgedType(resultType, true) + const resultBridge = bridgedResultType.getRequiredBridge() + if (resultBridge == null) + throw new Error( + `Result type (${bridgedResultType.getTypeCode('c++')}) does not have a bridge!` + ) + const bridgedErrorType = new SwiftCxxBridgedType(resultType.error, true) + + const returnType = new SwiftCxxBridgedType(method.returnType, true) const params = method.parameters.map((p) => { const bridgedType = new SwiftCxxBridgedType(p.type) return `${p.name}: ${bridgedType.getTypeCode('swift')}` @@ -428,19 +448,28 @@ function getMethodForwardImplementation(method: Method): string { const bridgedType = new SwiftCxxBridgedType(p.type) return `${p.name}: ${bridgedType.parseFromCppToSwift(p.name, 'swift')}` }) - const resultValue = returnType.hasType ? `let __result = ` : '' - const returnValue = returnType.hasType - ? `${returnType.parseFromSwiftToCpp('__result', 'swift')}` - : '' + let body: string + if (returnType.hasType) { + body = ` +let __result = try self.__implementation.${method.name}(${passParams.join(', ')}) +let __resultCpp = ${returnType.parseFromSwiftToCpp('__result', 'swift')} +return bridge.${resultBridge.funcName}(__resultCpp) +`.trim() + } else { + body = ` +try self.__implementation.${method.name}(${passParams.join(', ')}) +return bridge.${resultBridge.funcName}() +`.trim() + } + return ` @inline(__always) -public func ${method.name}(${params.join(', ')}) -> ${returnType.getTypeCode('swift')} { +public func ${method.name}(${params.join(', ')}) -> ${bridgedResultType.getTypeCode('swift')} { do { - ${resultValue}try self.__implementation.${method.name}(${indent(passParams.join(', '), ' ')}) - return ${indent(returnValue, ' ')} - } catch { - let __message = "\\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \\(__message))") + ${indent(body, ' ')} + } catch (let __error) { + let __exceptionPtr = ${indent(bridgedErrorType.parseFromSwiftToCpp('__error', 'swift'), ' ')} + return bridge.${resultBridge.funcName}(__exceptionPtr) } } `.trim() diff --git a/packages/nitrogen/src/syntax/types/ResultWrappingType.ts b/packages/nitrogen/src/syntax/types/ResultWrappingType.ts new file mode 100644 index 000000000..33fabe720 --- /dev/null +++ b/packages/nitrogen/src/syntax/types/ResultWrappingType.ts @@ -0,0 +1,49 @@ +import type { Language } from '../../getPlatformSpecs.js' +import { type SourceFile, type SourceImport } from '../SourceFile.js' +import { ErrorType } from './ErrorType.js' +import type { Type, TypeKind } from './Type.js' + +export class ResultWrappingType implements Type { + readonly result: Type + readonly error: Type + + constructor(result: Type) { + this.result = result + this.error = new ErrorType() + } + + get canBePassedByReference(): boolean { + return this.result.canBePassedByReference + } + + get kind(): TypeKind { + return 'result-wrapper' + } + + getCode(language: Language): string { + switch (language) { + case 'c++': + return `Result<${this.result.getCode(language)}>` + case 'swift': + return this.result.getCode(language) + default: + throw new Error( + `Language ${language} is not yet supported for VariantType!` + ) + } + } + getExtraFiles(): SourceFile[] { + return [...this.result.getExtraFiles(), ...this.error.getExtraFiles()] + } + getRequiredImports(): SourceImport[] { + return [ + { + language: 'c++', + name: 'NitroModules/Result.hpp', + space: 'system', + }, + ...this.result.getRequiredImports(), + ...this.error.getRequiredImports(), + ] + } +} diff --git a/packages/nitrogen/src/syntax/types/Type.ts b/packages/nitrogen/src/syntax/types/Type.ts index 818f016e7..17a5fb70a 100644 --- a/packages/nitrogen/src/syntax/types/Type.ts +++ b/packages/nitrogen/src/syntax/types/Type.ts @@ -21,6 +21,7 @@ export type TypeKind = | 'struct' | 'tuple' | 'variant' + | 'result-wrapper' | 'void' /** diff --git a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt index 20eac13a5..50bb43feb 100644 --- a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt +++ b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt @@ -93,6 +93,10 @@ class HybridTestObjectKotlin: HybridTestObjectSwiftKotlinSpec() { throw Error("This function will only work after sacrificing seven lambs!") } + override fun funcThatThrowsBeforePromise(): Promise { + throw Error("This function will only work after sacrificing eight lambs!") + } + override fun throwError(error: Throwable): Unit { throw error } diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp index 2c946cbd4..6c0752a60 100644 --- a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp +++ b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp @@ -190,6 +190,10 @@ double HybridTestObjectCpp::funcThatThrows() { throw std::runtime_error("This function will only work after sacrificing seven lambs!"); } +std::shared_ptr> HybridTestObjectCpp::funcThatThrowsBeforePromise() { + throw std::runtime_error("This function will only work after sacrificing eight lambs!"); +} + void HybridTestObjectCpp::throwError(const std::exception_ptr& error) { std::rethrow_exception(error); } diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp index 387cc48c2..0f78b5380 100644 --- a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp +++ b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp @@ -80,6 +80,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec { std::shared_ptr createMap() override; std::shared_ptr mapRoundtrip(const std::shared_ptr& map) override; double funcThatThrows() override; + std::shared_ptr> funcThatThrowsBeforePromise() override; void throwError(const std::exception_ptr& error) override; std::string tryOptionalParams(double num, bool boo, const std::optional& str) override; std::string tryMiddleParam(double num, std::optional boo, const std::string& str) override; diff --git a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift index c741f668c..cb167e94c 100644 --- a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift +++ b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift @@ -56,14 +56,14 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec { func callWithOptional(value: Double?, callback: @escaping ((_ maybe: Double?) -> Void)) throws -> Void { callback(value) } - + func getValueFromJSCallbackAndWait(getValue: @escaping (() -> Promise)) throws -> Promise { return .async { let jsResult = try await getValue().await() return jsResult } } - + func getValueFromJsCallback(callback: @escaping (() -> Promise), andThenCall: @escaping ((_ valueFromJs: String) -> Void)) throws -> Promise { return .async { let jsResult = try await callback().await() @@ -125,14 +125,15 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec { } func funcThatThrows() throws -> Double { - // TODO: Swift functions can not throw yet! Errors are not propagated up to C++. - // throw RuntimeError.error(withMessage: "This function will only work after sacrificing seven lambs!") - return 55 + throw RuntimeError.error(withMessage: "This function will only work after sacrificing seven lambs!") + } + + func funcThatThrowsBeforePromise() throws -> Promise { + throw RuntimeError.error(withMessage: "This function will only work after sacrificing eight lambs!") } func throwError(error: Error) throws -> Void { - // TODO: Swift functions can not throw yet! Errors are not propagated up to C++. - // throw error + throw error } func tryOptionalParams(num: Double, boo: Bool, str: String?) throws -> String { diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp index d4fa2eee0..086cb79c4 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp @@ -344,6 +344,21 @@ namespace margelo::nitro::image { auto __result = method(_javaPart); return __result; } + std::shared_ptr> JHybridTestObjectSwiftKotlinSpec::funcThatThrowsBeforePromise() { + static const auto method = _javaPart->getClass()->getMethod()>("funcThatThrowsBeforePromise"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + __promise->resolve(); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } void JHybridTestObjectSwiftKotlinSpec::throwError(const std::exception_ptr& error) { static const auto method = _javaPart->getClass()->getMethod /* error */)>("throwError"); method(_javaPart, jni::getJavaExceptionForCppException(error)); diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp index 1594402b9..990a405d4 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp @@ -88,6 +88,7 @@ namespace margelo::nitro::image { std::shared_ptr createMap() override; std::shared_ptr mapRoundtrip(const std::shared_ptr& map) override; double funcThatThrows() override; + std::shared_ptr> funcThatThrowsBeforePromise() override; void throwError(const std::exception_ptr& error) override; std::string tryOptionalParams(double num, bool boo, const std::optional& str) override; std::string tryMiddleParam(double num, std::optional boo, const std::string& str) override; diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt index 2c87b8934..b810d0032 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt +++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt @@ -174,6 +174,10 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { @Keep abstract fun funcThatThrows(): Double + @DoNotStrip + @Keep + abstract fun funcThatThrowsBeforePromise(): Promise + @DoNotStrip @Keep abstract fun throwError(error: Throwable): Unit diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp index b4af390cf..b73a81870 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp @@ -8,6 +8,8 @@ #pragma once // Forward declarations of C++ defined types +// Forward declaration of `AnyMap` to properly resolve imports. +namespace NitroModules { class AnyMap; } // Forward declaration of `ArrayBufferHolder` to properly resolve imports. namespace NitroModules { class ArrayBufferHolder; } // Forward declaration of `ArrayBuffer` to properly resolve imports. @@ -53,9 +55,11 @@ namespace NitroImage { class HybridTestObjectSwiftKotlinSpec_cxx; } #include "OldEnum.hpp" #include "Person.hpp" #include "Powertrain.hpp" +#include #include #include #include +#include #include #include #include @@ -110,6 +114,24 @@ namespace margelo::nitro::image::bridge::swift { using std__weak_ptr_margelo__nitro__image__HybridImageSpec_ = std::weak_ptr; inline std__weak_ptr_margelo__nitro__image__HybridImageSpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(const std::shared_ptr& strong) { return strong; } + // pragma MARK: Result + using Result_double_ = Result; + inline Result_double_ create_Result_double_(double value) { + return Result::withValue(std::move(value)); + } + inline Result_double_ create_Result_double_(const std::exception_ptr& error) { + return Result::withError(error); + } + + // pragma MARK: Result + using Result_void_ = Result; + inline Result_void_ create_Result_void_() { + return Result::withValue(); + } + inline Result_void_ create_Result_void_(const std::exception_ptr& error) { + return Result::withError(error); + } + // pragma MARK: std::shared_ptr /** * Specialized version of `std::shared_ptr`. @@ -122,6 +144,15 @@ namespace margelo::nitro::image::bridge::swift { using std__weak_ptr_margelo__nitro__image__HybridImageFactorySpec_ = std::weak_ptr; inline std__weak_ptr_margelo__nitro__image__HybridImageFactorySpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_(const std::shared_ptr& strong) { return strong; } + // pragma MARK: Result> + using Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ = Result>; + inline Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(const std::exception_ptr& error) { + return Result>::withError(error); + } + // pragma MARK: std::shared_ptr /** * Specialized version of `std::shared_ptr`. @@ -251,6 +282,71 @@ namespace margelo::nitro::image::bridge::swift { return std::make_shared(value); } + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_void__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_void__() { + return Promise::create(); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_Wrapper final { + public: + explicit Func_void_Wrapper(const std::function& func): _function(func) {} + explicit Func_void_Wrapper(std::function&& func): _function(std::move(func)) {} + inline void call() const { + _function(); + } + private: + std::function _function; + }; + inline Func_void create_Func_void(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { + std::shared_ptr sharedClosureHolder(closureHolder, destroy); + return Func_void([sharedClosureHolder, call]() -> void { + call(sharedClosureHolder.get()); + }); + } + inline std::shared_ptr share_Func_void(const Func_void& value) { + return std::make_shared(value); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_std__exception_ptr = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_std__exception_ptr_Wrapper final { + public: + explicit Func_void_std__exception_ptr_Wrapper(const std::function& func): _function(func) {} + explicit Func_void_std__exception_ptr_Wrapper(std::function&& func): _function(std::move(func)) {} + inline void call(std::exception_ptr error) const { + _function(error); + } + private: + std::function _function; + }; + inline Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, std::exception_ptr), void(* _Nonnull destroy)(void* _Nonnull)) { + std::shared_ptr sharedClosureHolder(closureHolder, destroy); + return Func_void_std__exception_ptr([sharedClosureHolder, call](const std::exception_ptr& error) -> void { + call(sharedClosureHolder.get(), error); + }); + } + inline std::shared_ptr share_Func_void_std__exception_ptr(const Func_void_std__exception_ptr& value) { + return std::make_shared(value); + } + // pragma MARK: std::optional /** * Specialized version of `std::optional`. @@ -326,71 +422,6 @@ namespace margelo::nitro::image::bridge::swift { return std::make_shared(value); } - // pragma MARK: std::function - /** - * Specialized version of `std::function`. - */ - using Func_void_std__exception_ptr = std::function; - /** - * Wrapper class for a `std::function`, this can be used from Swift. - */ - class Func_void_std__exception_ptr_Wrapper final { - public: - explicit Func_void_std__exception_ptr_Wrapper(const std::function& func): _function(func) {} - explicit Func_void_std__exception_ptr_Wrapper(std::function&& func): _function(std::move(func)) {} - inline void call(std::exception_ptr error) const { - _function(error); - } - private: - std::function _function; - }; - inline Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, std::exception_ptr), void(* _Nonnull destroy)(void* _Nonnull)) { - std::shared_ptr sharedClosureHolder(closureHolder, destroy); - return Func_void_std__exception_ptr([sharedClosureHolder, call](const std::exception_ptr& error) -> void { - call(sharedClosureHolder.get(), error); - }); - } - inline std::shared_ptr share_Func_void_std__exception_ptr(const Func_void_std__exception_ptr& value) { - return std::make_shared(value); - } - - // pragma MARK: std::shared_ptr> - /** - * Specialized version of `std::shared_ptr>`. - */ - using std__shared_ptr_Promise_void__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_void__() { - return Promise::create(); - } - - // pragma MARK: std::function - /** - * Specialized version of `std::function`. - */ - using Func_void = std::function; - /** - * Wrapper class for a `std::function`, this can be used from Swift. - */ - class Func_void_Wrapper final { - public: - explicit Func_void_Wrapper(const std::function& func): _function(func) {} - explicit Func_void_Wrapper(std::function&& func): _function(std::move(func)) {} - inline void call() const { - _function(); - } - private: - std::function _function; - }; - inline Func_void create_Func_void(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { - std::shared_ptr sharedClosureHolder(closureHolder, destroy); - return Func_void([sharedClosureHolder, call]() -> void { - call(sharedClosureHolder.get()); - }); - } - inline std::shared_ptr share_Func_void(const Func_void& value) { - return std::make_shared(value); - } - // pragma MARK: std::shared_ptr> /** * Specialized version of `std::shared_ptr>`. @@ -643,5 +674,185 @@ namespace margelo::nitro::image::bridge::swift { // pragma MARK: std::weak_ptr using std__weak_ptr_margelo__nitro__image__HybridChildSpec_ = std::weak_ptr; inline std__weak_ptr_margelo__nitro__image__HybridChildSpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(const std::shared_ptr& strong) { return strong; } + + // pragma MARK: Result> + using Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ = Result>; + inline Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result + using Result_std__string_ = Result; + inline Result_std__string_ create_Result_std__string_(const std::string& value) { + return Result::withValue(value); + } + inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) { + return Result::withError(error); + } + + // pragma MARK: Result> + using Result_std__vector_std__string__ = Result>; + inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::vector& value) { + return Result>::withValue(value); + } + inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__vector_double__ = Result>; + inline Result_std__vector_double__ create_Result_std__vector_double__(const std::vector& value) { + return Result>::withValue(value); + } + inline Result_std__vector_double__ create_Result_std__vector_double__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__vector_Person__ = Result>; + inline Result_std__vector_Person__ create_Result_std__vector_Person__(const std::vector& value) { + return Result>::withValue(value); + } + inline Result_std__vector_Person__ create_Result_std__vector_Person__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__vector_Powertrain__ = Result>; + inline Result_std__vector_Powertrain__ create_Result_std__vector_Powertrain__(const std::vector& value) { + return Result>::withValue(value); + } + inline Result_std__vector_Powertrain__ create_Result_std__vector_Powertrain__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__shared_ptr_AnyMap__ = Result>; + inline Result_std__shared_ptr_AnyMap__ create_Result_std__shared_ptr_AnyMap__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_AnyMap__ create_Result_std__shared_ptr_AnyMap__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_void___ = Result>>; + inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr>& value) { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) { + return Result>>::withError(error); + } + + // pragma MARK: Result> + using Result_std__optional_Powertrain__ = Result>; + inline Result_std__optional_Powertrain__ create_Result_std__optional_Powertrain__(std::optional value) { + return Result>::withValue(std::move(value)); + } + inline Result_std__optional_Powertrain__ create_Result_std__optional_Powertrain__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result + using Result_int64_t_ = Result; + inline Result_int64_t_ create_Result_int64_t_(int64_t value) { + return Result::withValue(std::move(value)); + } + inline Result_int64_t_ create_Result_int64_t_(const std::exception_ptr& error) { + return Result::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_int64_t___ = Result>>; + inline Result_std__shared_ptr_Promise_int64_t___ create_Result_std__shared_ptr_Promise_int64_t___(const std::shared_ptr>& value) { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_int64_t___ create_Result_std__shared_ptr_Promise_int64_t___(const std::exception_ptr& error) { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_double___ = Result>>; + inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr>& value) { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_Car___ = Result>>; + inline Result_std__shared_ptr_Promise_Car___ create_Result_std__shared_ptr_Promise_Car___(const std::shared_ptr>& value) { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_Car___ create_Result_std__shared_ptr_Promise_Car___(const std::exception_ptr& error) { + return Result>>::withError(error); + } + + // pragma MARK: Result + using Result_Car_ = Result; + inline Result_Car_ create_Result_Car_(const Car& value) { + return Result::withValue(value); + } + inline Result_Car_ create_Result_Car_(const std::exception_ptr& error) { + return Result::withError(error); + } + + // pragma MARK: Result + using Result_bool_ = Result; + inline Result_bool_ create_Result_bool_(bool value) { + return Result::withValue(std::move(value)); + } + inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) { + return Result::withError(error); + } + + // pragma MARK: Result> + using Result_std__optional_Person__ = Result>; + inline Result_std__optional_Person__ create_Result_std__optional_Person__(const std::optional& value) { + return Result>::withValue(value); + } + inline Result_std__optional_Person__ create_Result_std__optional_Person__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__shared_ptr_ArrayBuffer__ = Result>; + inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result>>> + using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result>>>; + inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr>>& value) { + return Result>>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) { + return Result>>>::withError(error); + } + + // pragma MARK: Result> + using Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ = Result>; + inline Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(const std::exception_ptr& error) { + return Result>::withError(error); + } + + // pragma MARK: Result> + using Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ = Result>; + inline Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(const std::shared_ptr& value) { + return Result>::withValue(value); + } + inline Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(const std::exception_ptr& error) { + return Result>::withError(error); + } } // namespace margelo::nitro::image::bridge::swift diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp index be7d243d5..693b60e3a 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp @@ -53,6 +53,7 @@ namespace margelo::nitro::image { enum class Powertrain; } #include #include #include +#include #include #include #include diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp index a550d3efc..25eb95c0b 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp @@ -58,19 +58,35 @@ namespace margelo::nitro::image { // Methods inline std::shared_ptr loadImageFromFile(const std::string& path) override { auto __result = _swiftPart.loadImageFromFile(path); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr loadImageFromURL(const std::string& path) override { auto __result = _swiftPart.loadImageFromURL(path); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr loadImageFromSystemName(const std::string& path) override { auto __result = _swiftPart.loadImageFromSystemName(path); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr bounceBack(const std::shared_ptr& image) override { auto __result = _swiftPart.bounceBack(image); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } private: diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp index 5e5600cd9..d414a6daf 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp @@ -77,10 +77,17 @@ namespace margelo::nitro::image { // Methods inline double toArrayBuffer(ImageFormat format) override { auto __result = _swiftPart.toArrayBuffer(static_cast(format)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void saveToFile(const std::string& path, const std::function& onFinished) override { - _swiftPart.saveToFile(path, onFinished); + auto __result = _swiftPart.saveToFile(path, onFinished); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } private: diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp index 460fd40a2..1f9c171c6 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp @@ -44,8 +44,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; } #include "Person.hpp" #include #include -#include #include +#include #include "Car.hpp" #include #include @@ -175,167 +175,339 @@ namespace margelo::nitro::image { // Methods inline std::shared_ptr newTestObject() override { auto __result = _swiftPart.newTestObject(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void simpleFunc() override { - _swiftPart.simpleFunc(); + auto __result = _swiftPart.simpleFunc(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline double addNumbers(double a, double b) override { auto __result = _swiftPart.addNumbers(std::forward(a), std::forward(b)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::string addStrings(const std::string& a, const std::string& b) override { auto __result = _swiftPart.addStrings(a, b); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void multipleArguments(double num, const std::string& str, bool boo) override { - _swiftPart.multipleArguments(std::forward(num), str, std::forward(boo)); + auto __result = _swiftPart.multipleArguments(std::forward(num), str, std::forward(boo)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline std::vector bounceStrings(const std::vector& array) override { auto __result = _swiftPart.bounceStrings(array); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::vector bounceNumbers(const std::vector& array) override { auto __result = _swiftPart.bounceNumbers(array); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::vector bounceStructs(const std::vector& array) override { auto __result = _swiftPart.bounceStructs(array); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::vector bounceEnums(const std::vector& array) override { auto __result = _swiftPart.bounceEnums(array); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void complexEnumCallback(const std::vector& array, const std::function& /* array */)>& callback) override { - _swiftPart.complexEnumCallback(array, callback); + auto __result = _swiftPart.complexEnumCallback(array, callback); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline std::shared_ptr createMap() override { auto __result = _swiftPart.createMap(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr mapRoundtrip(const std::shared_ptr& map) override { auto __result = _swiftPart.mapRoundtrip(map); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline double funcThatThrows() override { auto __result = _swiftPart.funcThatThrows(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> funcThatThrowsBeforePromise() override { + auto __result = _swiftPart.funcThatThrowsBeforePromise(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void throwError(const std::exception_ptr& error) override { - _swiftPart.throwError(error); + auto __result = _swiftPart.throwError(error); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline std::string tryOptionalParams(double num, bool boo, const std::optional& str) override { auto __result = _swiftPart.tryOptionalParams(std::forward(num), std::forward(boo), str); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::string tryMiddleParam(double num, std::optional boo, const std::string& str) override { auto __result = _swiftPart.tryMiddleParam(std::forward(num), boo, str); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::optional tryOptionalEnum(std::optional value) override { auto __result = _swiftPart.tryOptionalEnum(value); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline int64_t calculateFibonacciSync(double value) override { auto __result = _swiftPart.calculateFibonacciSync(std::forward(value)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> calculateFibonacciAsync(double value) override { auto __result = _swiftPart.calculateFibonacciAsync(std::forward(value)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> wait(double seconds) override { auto __result = _swiftPart.wait(std::forward(seconds)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> promiseThrows() override { auto __result = _swiftPart.promiseThrows(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> awaitAndGetPromise(const std::shared_ptr>& promise) override { auto __result = _swiftPart.awaitAndGetPromise(promise); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> awaitAndGetComplexPromise(const std::shared_ptr>& promise) override { auto __result = _swiftPart.awaitAndGetComplexPromise(promise); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> awaitPromise(const std::shared_ptr>& promise) override { auto __result = _swiftPart.awaitPromise(promise); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void callCallback(const std::function& callback) override { - _swiftPart.callCallback(callback); + auto __result = _swiftPart.callCallback(callback); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline void callAll(const std::function& first, const std::function& second, const std::function& third) override { - _swiftPart.callAll(first, second, third); + auto __result = _swiftPart.callAll(first, second, third); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline void callWithOptional(std::optional value, const std::function /* maybe */)>& callback) override { - _swiftPart.callWithOptional(value, callback); + auto __result = _swiftPart.callWithOptional(value, callback); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline std::shared_ptr> getValueFromJSCallbackAndWait(const std::function>()>& getValue) override { auto __result = _swiftPart.getValueFromJSCallbackAndWait(getValue); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr> getValueFromJsCallback(const std::function>()>& callback, const std::function& andThenCall) override { auto __result = _swiftPart.getValueFromJsCallback(callback, andThenCall); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline Car getCar() override { auto __result = _swiftPart.getCar(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline bool isCarElectric(const Car& car) override { auto __result = _swiftPart.isCarElectric(car); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::optional getDriver(const Car& car) override { auto __result = _swiftPart.getDriver(car); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr createArrayBuffer() override { auto __result = _swiftPart.createArrayBuffer(); - return __result.getArrayBuffer(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline double getBufferLastItem(const std::shared_ptr& buffer) override { auto __result = _swiftPart.getBufferLastItem(ArrayBufferHolder(buffer)); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline void setAllValuesTo(const std::shared_ptr& buffer, double value) override { - _swiftPart.setAllValuesTo(ArrayBufferHolder(buffer), std::forward(value)); + auto __result = _swiftPart.setAllValuesTo(ArrayBufferHolder(buffer), std::forward(value)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } } inline std::shared_ptr>> createArrayBufferAsync() override { auto __result = _swiftPart.createArrayBufferAsync(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr createChild() override { auto __result = _swiftPart.createChild(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr createBase() override { auto __result = _swiftPart.createBase(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr createBaseActualChild() override { auto __result = _swiftPart.createBaseActualChild(); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr bounceChild(const std::shared_ptr& child) override { auto __result = _swiftPart.bounceChild(child); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr bounceBase(const std::shared_ptr& base) override { auto __result = _swiftPart.bounceBase(base); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr bounceChildBase(const std::shared_ptr& child) override { auto __result = _swiftPart.bounceChildBase(child); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } inline std::shared_ptr castBase(const std::shared_ptr& base) override { auto __result = _swiftPart.castBase(base); - return __result; + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; } private: diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift index 88d081ad9..aa8b997b7 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift @@ -101,62 +101,66 @@ public class HybridImageFactorySpec_cxx { // Methods @inline(__always) - public func loadImageFromFile(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ { + public func loadImageFromFile(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ { do { let __result = try self.__implementation.loadImageFromFile(path: String(path)) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr) } } @inline(__always) - public func loadImageFromURL(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ { + public func loadImageFromURL(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ { do { let __result = try self.__implementation.loadImageFromURL(path: String(path)) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr) } } @inline(__always) - public func loadImageFromSystemName(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ { + public func loadImageFromSystemName(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ { do { let __result = try self.__implementation.loadImageFromSystemName(path: String(path)) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr) } } @inline(__always) - public func bounceBack(image: bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ { + public func bounceBack(image: bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ { do { let __result = try self.__implementation.bounceBack(image: { () -> HybridImageSpec in let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(image) let __instance = HybridImageSpec_cxx.fromUnsafe(__unsafePointer) return __instance.getHybridImageSpec() }()) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr) } } } diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift index 83d122d8d..6a7c906d6 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift @@ -124,18 +124,19 @@ public class HybridImageSpec_cxx { // Methods @inline(__always) - public func toArrayBuffer(format: Int32) -> Double { + public func toArrayBuffer(format: Int32) -> bridge.Result_double_ { do { let __result = try self.__implementation.toArrayBuffer(format: margelo.nitro.image.ImageFormat(rawValue: format)!) - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + 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 func saveToFile(path: std.string, onFinished: bridge.Func_void_std__string) -> Void { + public func saveToFile(path: std.string, onFinished: bridge.Func_void_std__string) -> bridge.Result_void_ { do { try self.__implementation.saveToFile(path: String(path), onFinished: { () -> ((String) -> Void) in let __sharedClosure = bridge.share_Func_void_std__string(onFinished) @@ -143,10 +144,10 @@ public class HybridImageSpec_cxx { __sharedClosure.pointee.call(std.string(__path)) } }()) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } } diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift index 786b2d89c..3f2faddb1 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift @@ -39,6 +39,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: AnyObject { func createMap() throws -> AnyMapHolder func mapRoundtrip(map: AnyMapHolder) throws -> AnyMapHolder func funcThatThrows() throws -> Double + func funcThatThrowsBeforePromise() throws -> Promise func throwError(error: Error) throws -> Void func tryOptionalParams(num: Double, boo: Bool, str: String?) throws -> String func tryMiddleParam(num: Double, boo: Bool?, str: String) throws -> String diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift index 6155ce89c..883a3e348 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift +++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift @@ -344,133 +344,140 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { // Methods @inline(__always) - public func newTestObject() -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ { + public func newTestObject() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ { do { let __result = try self.__implementation.newTestObject() - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(__exceptionPtr) } } @inline(__always) - public func simpleFunc() -> Void { + public func simpleFunc() -> bridge.Result_void_ { do { try self.__implementation.simpleFunc() - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func addNumbers(a: Double, b: Double) -> Double { + public func addNumbers(a: Double, b: Double) -> bridge.Result_double_ { do { let __result = try self.__implementation.addNumbers(a: a, b: b) - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + 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 func addStrings(a: std.string, b: std.string) -> std.string { + public func addStrings(a: std.string, b: std.string) -> bridge.Result_std__string_ { do { let __result = try self.__implementation.addStrings(a: String(a), b: String(b)) - return std.string(__result) - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = std.string(__result) + return bridge.create_Result_std__string_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__string_(__exceptionPtr) } } @inline(__always) - public func multipleArguments(num: Double, str: std.string, boo: Bool) -> Void { + public func multipleArguments(num: Double, str: std.string, boo: Bool) -> bridge.Result_void_ { do { try self.__implementation.multipleArguments(num: num, str: String(str), boo: boo) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func bounceStrings(array: bridge.std__vector_std__string_) -> bridge.std__vector_std__string_ { + public func bounceStrings(array: bridge.std__vector_std__string_) -> bridge.Result_std__vector_std__string__ { do { let __result = try self.__implementation.bounceStrings(array: array.map({ __item in String(__item) })) - return { () -> bridge.std__vector_std__string_ in + let __resultCpp = { () -> bridge.std__vector_std__string_ in var __vector = bridge.create_std__vector_std__string_(__result.count) for __item in __result { __vector.push_back(std.string(__item)) } return __vector }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__vector_std__string__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__vector_std__string__(__exceptionPtr) } } @inline(__always) - public func bounceNumbers(array: bridge.std__vector_double_) -> bridge.std__vector_double_ { + public func bounceNumbers(array: bridge.std__vector_double_) -> bridge.Result_std__vector_double__ { do { let __result = try self.__implementation.bounceNumbers(array: array.map({ __item in __item })) - return { () -> bridge.std__vector_double_ in + let __resultCpp = { () -> bridge.std__vector_double_ in var __vector = bridge.create_std__vector_double_(__result.count) for __item in __result { __vector.push_back(__item) } return __vector }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__vector_double__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__vector_double__(__exceptionPtr) } } @inline(__always) - public func bounceStructs(array: bridge.std__vector_Person_) -> bridge.std__vector_Person_ { + public func bounceStructs(array: bridge.std__vector_Person_) -> bridge.Result_std__vector_Person__ { do { let __result = try self.__implementation.bounceStructs(array: array.map({ __item in __item })) - return { () -> bridge.std__vector_Person_ in + let __resultCpp = { () -> bridge.std__vector_Person_ in var __vector = bridge.create_std__vector_Person_(__result.count) for __item in __result { __vector.push_back(__item) } return __vector }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__vector_Person__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__vector_Person__(__exceptionPtr) } } @inline(__always) - public func bounceEnums(array: bridge.std__vector_Powertrain_) -> bridge.std__vector_Powertrain_ { + public func bounceEnums(array: bridge.std__vector_Powertrain_) -> bridge.Result_std__vector_Powertrain__ { do { let __result = try self.__implementation.bounceEnums(array: array.map({ __item in __item })) - return { () -> bridge.std__vector_Powertrain_ in + let __resultCpp = { () -> bridge.std__vector_Powertrain_ in var __vector = bridge.create_std__vector_Powertrain_(__result.count) for __item in __result { __vector.push_back(__item) } return __vector }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__vector_Powertrain__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__vector_Powertrain__(__exceptionPtr) } } @inline(__always) - public func complexEnumCallback(array: bridge.std__vector_Powertrain_, callback: bridge.Func_void_std__vector_Powertrain_) -> Void { + public func complexEnumCallback(array: bridge.std__vector_Powertrain_, callback: bridge.Func_void_std__vector_Powertrain_) -> bridge.Result_void_ { do { try self.__implementation.complexEnumCallback(array: array.map({ __item in __item }), callback: { () -> (([Powertrain]) -> Void) in let __sharedClosure = bridge.share_Func_void_std__vector_Powertrain_(callback) @@ -484,59 +491,80 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { }()) } }()) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func createMap() -> margelo.nitro.TSharedMap { + public func createMap() -> bridge.Result_std__shared_ptr_AnyMap__ { do { let __result = try self.__implementation.createMap() - return __result.cppPart - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result.cppPart + return bridge.create_Result_std__shared_ptr_AnyMap__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_AnyMap__(__exceptionPtr) } } @inline(__always) - public func mapRoundtrip(map: margelo.nitro.TSharedMap) -> margelo.nitro.TSharedMap { + public func mapRoundtrip(map: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_AnyMap__ { do { let __result = try self.__implementation.mapRoundtrip(map: AnyMapHolder(withCppPart: map)) - return __result.cppPart - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result.cppPart + return bridge.create_Result_std__shared_ptr_AnyMap__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_AnyMap__(__exceptionPtr) } } @inline(__always) - public func funcThatThrows() -> Double { + public func funcThatThrows() -> bridge.Result_double_ { do { let __result = try self.__implementation.funcThatThrows() - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + 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 func throwError(error: std.exception_ptr) -> Void { + public func funcThatThrowsBeforePromise() -> bridge.Result_std__shared_ptr_Promise_void___ { + do { + let __result = try self.__implementation.funcThatThrowsBeforePromise() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in + let __promise = bridge.create_std__shared_ptr_Promise_void__() + __result + .then({ __result in __promise.pointee.resolve() }) + .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) + } + } + + @inline(__always) + public func throwError(error: std.exception_ptr) -> bridge.Result_void_ { do { try self.__implementation.throwError(error: RuntimeError.from(cppError: error)) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func tryOptionalParams(num: Double, boo: Bool, str: bridge.std__optional_std__string_) -> std.string { + public func tryOptionalParams(num: Double, boo: Bool, str: bridge.std__optional_std__string_) -> bridge.Result_std__string_ { do { let __result = try self.__implementation.tryOptionalParams(num: num, boo: boo, str: { () -> String? in if let __unwrapped = str.value { @@ -545,105 +573,112 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return nil } }()) - return std.string(__result) - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = std.string(__result) + return bridge.create_Result_std__string_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__string_(__exceptionPtr) } } @inline(__always) - public func tryMiddleParam(num: Double, boo: bridge.std__optional_bool_, str: std.string) -> std.string { + public func tryMiddleParam(num: Double, boo: bridge.std__optional_bool_, str: std.string) -> bridge.Result_std__string_ { do { let __result = try self.__implementation.tryMiddleParam(num: num, boo: boo.value, str: String(str)) - return std.string(__result) - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = std.string(__result) + return bridge.create_Result_std__string_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__string_(__exceptionPtr) } } @inline(__always) - public func tryOptionalEnum(value: bridge.std__optional_Powertrain_) -> bridge.std__optional_Powertrain_ { + public func tryOptionalEnum(value: bridge.std__optional_Powertrain_) -> bridge.Result_std__optional_Powertrain__ { do { let __result = try self.__implementation.tryOptionalEnum(value: value.value) - return { () -> bridge.std__optional_Powertrain_ in + let __resultCpp = { () -> bridge.std__optional_Powertrain_ in if let __unwrappedValue = __result { return bridge.create_std__optional_Powertrain_(__unwrappedValue) } else { return .init() } }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__optional_Powertrain__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__optional_Powertrain__(__exceptionPtr) } } @inline(__always) - public func calculateFibonacciSync(value: Double) -> Int64 { + public func calculateFibonacciSync(value: Double) -> bridge.Result_int64_t_ { do { let __result = try self.__implementation.calculateFibonacciSync(value: value) - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result + return bridge.create_Result_int64_t_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_int64_t_(__exceptionPtr) } } @inline(__always) - public func calculateFibonacciAsync(value: Double) -> bridge.std__shared_ptr_Promise_int64_t__ { + public func calculateFibonacciAsync(value: Double) -> bridge.Result_std__shared_ptr_Promise_int64_t___ { do { let __result = try self.__implementation.calculateFibonacciAsync(value: value) - return { () -> bridge.std__shared_ptr_Promise_int64_t__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_int64_t__ in let __promise = bridge.create_std__shared_ptr_Promise_int64_t__() __result .then({ __result in __promise.pointee.resolve(__result) }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_int64_t___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_int64_t___(__exceptionPtr) } } @inline(__always) - public func wait(seconds: Double) -> bridge.std__shared_ptr_Promise_void__ { + public func wait(seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.wait(seconds: seconds) - return { () -> bridge.std__shared_ptr_Promise_void__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in let __promise = bridge.create_std__shared_ptr_Promise_void__() __result .then({ __result in __promise.pointee.resolve() }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) } } @inline(__always) - public func promiseThrows() -> bridge.std__shared_ptr_Promise_void__ { + public func promiseThrows() -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.promiseThrows() - return { () -> bridge.std__shared_ptr_Promise_void__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in let __promise = bridge.create_std__shared_ptr_Promise_void__() __result .then({ __result in __promise.pointee.resolve() }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) } } @inline(__always) - public func awaitAndGetPromise(promise: bridge.std__shared_ptr_Promise_double__) -> bridge.std__shared_ptr_Promise_double__ { + public func awaitAndGetPromise(promise: bridge.std__shared_ptr_Promise_double__) -> bridge.Result_std__shared_ptr_Promise_double___ { do { let __result = try self.__implementation.awaitAndGetPromise(promise: { () -> Promise in let __promise = Promise() @@ -701,21 +736,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { promise.pointee.addOnRejectedListener(__rejecterCpp) return __promise }()) - return { () -> bridge.std__shared_ptr_Promise_double__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in let __promise = bridge.create_std__shared_ptr_Promise_double__() __result .then({ __result in __promise.pointee.resolve(__result) }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr) } } @inline(__always) - public func awaitAndGetComplexPromise(promise: bridge.std__shared_ptr_Promise_Car__) -> bridge.std__shared_ptr_Promise_Car__ { + public func awaitAndGetComplexPromise(promise: bridge.std__shared_ptr_Promise_Car__) -> bridge.Result_std__shared_ptr_Promise_Car___ { do { let __result = try self.__implementation.awaitAndGetComplexPromise(promise: { () -> Promise in let __promise = Promise() @@ -773,21 +809,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { promise.pointee.addOnRejectedListener(__rejecterCpp) return __promise }()) - return { () -> bridge.std__shared_ptr_Promise_Car__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_Car__ in let __promise = bridge.create_std__shared_ptr_Promise_Car__() __result .then({ __result in __promise.pointee.resolve(__result) }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_Car___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_Car___(__exceptionPtr) } } @inline(__always) - public func awaitPromise(promise: bridge.std__shared_ptr_Promise_void__) -> bridge.std__shared_ptr_Promise_void__ { + public func awaitPromise(promise: bridge.std__shared_ptr_Promise_void__) -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.awaitPromise(promise: { () -> Promise in let __promise = Promise() @@ -822,21 +859,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { promise.pointee.addOnRejectedListener(__rejecterCpp) return __promise }()) - return { () -> bridge.std__shared_ptr_Promise_void__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in let __promise = bridge.create_std__shared_ptr_Promise_void__() __result .then({ __result in __promise.pointee.resolve() }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) } } @inline(__always) - public func callCallback(callback: bridge.Func_void) -> Void { + public func callCallback(callback: bridge.Func_void) -> bridge.Result_void_ { do { try self.__implementation.callCallback(callback: { () -> (() -> Void) in let __sharedClosure = bridge.share_Func_void(callback) @@ -844,15 +882,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { __sharedClosure.pointee.call() } }()) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func callAll(first: bridge.Func_void, second: bridge.Func_void, third: bridge.Func_void) -> Void { + public func callAll(first: bridge.Func_void, second: bridge.Func_void, third: bridge.Func_void) -> bridge.Result_void_ { do { try self.__implementation.callAll(first: { () -> (() -> Void) in let __sharedClosure = bridge.share_Func_void(first) @@ -870,15 +908,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { __sharedClosure.pointee.call() } }()) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func callWithOptional(value: bridge.std__optional_double_, callback: bridge.Func_void_std__optional_double_) -> Void { + public func callWithOptional(value: bridge.std__optional_double_, callback: bridge.Func_void_std__optional_double_) -> bridge.Result_void_ { do { try self.__implementation.callWithOptional(value: value.value, callback: { () -> ((Double?) -> Void) in let __sharedClosure = bridge.share_Func_void_std__optional_double_(callback) @@ -892,15 +930,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { }()) } }()) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func getValueFromJSCallbackAndWait(getValue: bridge.Func_std__shared_ptr_Promise_double__) -> bridge.std__shared_ptr_Promise_double__ { + public func getValueFromJSCallbackAndWait(getValue: bridge.Func_std__shared_ptr_Promise_double__) -> bridge.Result_std__shared_ptr_Promise_double___ { do { let __result = try self.__implementation.getValueFromJSCallbackAndWait(getValue: { () -> (() -> Promise) in let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_double__(getValue) @@ -964,21 +1002,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { }() } }()) - return { () -> bridge.std__shared_ptr_Promise_double__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in let __promise = bridge.create_std__shared_ptr_Promise_double__() __result .then({ __result in __promise.pointee.resolve(__result) }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr) } } @inline(__always) - public func getValueFromJsCallback(callback: bridge.Func_std__shared_ptr_Promise_std__string__, andThenCall: bridge.Func_void_std__string) -> bridge.std__shared_ptr_Promise_void__ { + public func getValueFromJsCallback(callback: bridge.Func_std__shared_ptr_Promise_std__string__, andThenCall: bridge.Func_void_std__string) -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.getValueFromJsCallback(callback: { () -> (() -> Promise) in let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_std__string__(callback) @@ -1047,219 +1086,233 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { __sharedClosure.pointee.call(std.string(__valueFromJs)) } }()) - return { () -> bridge.std__shared_ptr_Promise_void__ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in let __promise = bridge.create_std__shared_ptr_Promise_void__() __result .then({ __result in __promise.pointee.resolve() }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) } } @inline(__always) - public func getCar() -> Car { + public func getCar() -> bridge.Result_Car_ { do { let __result = try self.__implementation.getCar() - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result + return bridge.create_Result_Car_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_Car_(__exceptionPtr) } } @inline(__always) - public func isCarElectric(car: Car) -> Bool { + public func isCarElectric(car: Car) -> bridge.Result_bool_ { do { let __result = try self.__implementation.isCarElectric(car: car) - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result + return bridge.create_Result_bool_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_bool_(__exceptionPtr) } } @inline(__always) - public func getDriver(car: Car) -> bridge.std__optional_Person_ { + public func getDriver(car: Car) -> bridge.Result_std__optional_Person__ { do { let __result = try self.__implementation.getDriver(car: car) - return { () -> bridge.std__optional_Person_ in + let __resultCpp = { () -> bridge.std__optional_Person_ in if let __unwrappedValue = __result { return bridge.create_std__optional_Person_(__unwrappedValue) } else { return .init() } }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__optional_Person__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__optional_Person__(__exceptionPtr) } } @inline(__always) - public func createArrayBuffer() -> ArrayBufferHolder { + public func createArrayBuffer() -> bridge.Result_std__shared_ptr_ArrayBuffer__ { do { let __result = try self.__implementation.createArrayBuffer() - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + let __resultCpp = __result.getArrayBuffer() + return bridge.create_Result_std__shared_ptr_ArrayBuffer__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_ArrayBuffer__(__exceptionPtr) } } @inline(__always) - public func getBufferLastItem(buffer: ArrayBufferHolder) -> Double { + public func getBufferLastItem(buffer: ArrayBufferHolder) -> bridge.Result_double_ { do { let __result = try self.__implementation.getBufferLastItem(buffer: buffer) - return __result - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + 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 func setAllValuesTo(buffer: ArrayBufferHolder, value: Double) -> Void { + public func setAllValuesTo(buffer: ArrayBufferHolder, value: Double) -> bridge.Result_void_ { do { try self.__implementation.setAllValuesTo(buffer: buffer, value: value) - return - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) } } @inline(__always) - public func createArrayBufferAsync() -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ { + public func createArrayBufferAsync() -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ { do { let __result = try self.__implementation.createArrayBufferAsync() - return { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() __result .then({ __result in __promise.pointee.resolve(__result.getArrayBuffer()) }) .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) return __promise }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__exceptionPtr) } } @inline(__always) - public func createChild() -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ { + public func createChild() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ { do { let __result = try self.__implementation.createChild() - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr) } } @inline(__always) - public func createBase() -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ { + public func createBase() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ { do { let __result = try self.__implementation.createBase() - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr) } } @inline(__always) - public func createBaseActualChild() -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ { + public func createBaseActualChild() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ { do { let __result = try self.__implementation.createBaseActualChild() - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr) } } @inline(__always) - public func bounceChild(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ { + public func bounceChild(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ { do { let __result = try self.__implementation.bounceChild(child: { () -> HybridChildSpec in let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(child) let __instance = HybridChildSpec_cxx.fromUnsafe(__unsafePointer) return __instance.getHybridChildSpec() }()) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr) } } @inline(__always) - public func bounceBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ { + public func bounceBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ { do { let __result = try self.__implementation.bounceBase(base: { () -> HybridBaseSpec in let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(base) let __instance = HybridBaseSpec_cxx.fromUnsafe(__unsafePointer) return __instance.getHybridBaseSpec() }()) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr) } } @inline(__always) - public func bounceChildBase(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ { + public func bounceChildBase(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ { do { let __result = try self.__implementation.bounceChildBase(child: { () -> HybridChildSpec in let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(child) let __instance = HybridChildSpec_cxx.fromUnsafe(__unsafePointer) return __instance.getHybridChildSpec() }()) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr) } } @inline(__always) - public func castBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ { + public func castBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ { do { let __result = try self.__implementation.castBase(base: { () -> HybridBaseSpec in let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(base) let __instance = HybridBaseSpec_cxx.fromUnsafe(__unsafePointer) return __instance.getHybridBaseSpec() }()) - return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in + let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in let __cxxWrapped = __result.getCxxWrapper() return __cxxWrapped.getCxxPart() }() - } catch { - let __message = "\(error.localizedDescription)" - fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))") + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr) } } } diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp index 60484e1d3..f77453d7b 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp +++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp @@ -61,6 +61,7 @@ namespace margelo::nitro::image { prototype.registerHybridMethod("createMap", &HybridTestObjectCppSpec::createMap); prototype.registerHybridMethod("mapRoundtrip", &HybridTestObjectCppSpec::mapRoundtrip); prototype.registerHybridMethod("funcThatThrows", &HybridTestObjectCppSpec::funcThatThrows); + prototype.registerHybridMethod("funcThatThrowsBeforePromise", &HybridTestObjectCppSpec::funcThatThrowsBeforePromise); prototype.registerHybridMethod("throwError", &HybridTestObjectCppSpec::throwError); prototype.registerHybridMethod("tryOptionalParams", &HybridTestObjectCppSpec::tryOptionalParams); prototype.registerHybridMethod("tryMiddleParam", &HybridTestObjectCppSpec::tryMiddleParam); diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp index 38eb41fd2..f92050e14 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp @@ -45,8 +45,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; } #include "Person.hpp" #include #include -#include #include +#include #include #include "HybridChildSpec.hpp" #include "HybridBaseSpec.hpp" @@ -128,6 +128,7 @@ namespace margelo::nitro::image { virtual std::shared_ptr createMap() = 0; virtual std::shared_ptr mapRoundtrip(const std::shared_ptr& map) = 0; virtual double funcThatThrows() = 0; + virtual std::shared_ptr> funcThatThrowsBeforePromise() = 0; virtual void throwError(const std::exception_ptr& error) = 0; virtual std::string tryOptionalParams(double num, bool boo, const std::optional& str) = 0; virtual std::string tryMiddleParam(double num, std::optional boo, const std::string& str) = 0; diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp index 1d351c012..0769279fb 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp @@ -52,6 +52,7 @@ namespace margelo::nitro::image { prototype.registerHybridMethod("createMap", &HybridTestObjectSwiftKotlinSpec::createMap); prototype.registerHybridMethod("mapRoundtrip", &HybridTestObjectSwiftKotlinSpec::mapRoundtrip); prototype.registerHybridMethod("funcThatThrows", &HybridTestObjectSwiftKotlinSpec::funcThatThrows); + prototype.registerHybridMethod("funcThatThrowsBeforePromise", &HybridTestObjectSwiftKotlinSpec::funcThatThrowsBeforePromise); prototype.registerHybridMethod("throwError", &HybridTestObjectSwiftKotlinSpec::throwError); prototype.registerHybridMethod("tryOptionalParams", &HybridTestObjectSwiftKotlinSpec::tryOptionalParams); prototype.registerHybridMethod("tryMiddleParam", &HybridTestObjectSwiftKotlinSpec::tryMiddleParam); diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp index fd28291cc..7c0a5e719 100644 --- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp @@ -43,8 +43,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; } #include "Person.hpp" #include #include -#include #include +#include #include "Car.hpp" #include #include "HybridChildSpec.hpp" @@ -118,6 +118,7 @@ namespace margelo::nitro::image { virtual std::shared_ptr createMap() = 0; virtual std::shared_ptr mapRoundtrip(const std::shared_ptr& map) = 0; virtual double funcThatThrows() = 0; + virtual std::shared_ptr> funcThatThrowsBeforePromise() = 0; virtual void throwError(const std::exception_ptr& error) = 0; virtual std::string tryOptionalParams(double num, bool boo, const std::optional& str) = 0; virtual std::string tryMiddleParam(double num, std::optional boo, const std::string& str) = 0; diff --git a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts index 7cfe107aa..8dc345103 100644 --- a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts @@ -74,6 +74,7 @@ interface SharedTestObjectProps { // Errors funcThatThrows(): number + funcThatThrowsBeforePromise(): Promise throwError(error: Error): void // Optional parameters diff --git a/packages/react-native-nitro-modules/NitroModules.podspec b/packages/react-native-nitro-modules/NitroModules.podspec index a5cefcc70..d697b8fc3 100644 --- a/packages/react-native-nitro-modules/NitroModules.podspec +++ b/packages/react-native-nitro-modules/NitroModules.podspec @@ -47,6 +47,7 @@ Pod::Spec.new do |s| "ios/core/ArrayBufferHolder.hpp", "ios/core/AnyMapHolder.hpp", "ios/core/HybridContext.hpp", + "ios/utils/Result.hpp", "ios/utils/RuntimeError.hpp", "ios/utils/SwiftClosure.hpp", ] diff --git a/packages/react-native-nitro-modules/ios/utils/Result.hpp b/packages/react-native-nitro-modules/ios/utils/Result.hpp new file mode 100644 index 000000000..16b00aea7 --- /dev/null +++ b/packages/react-native-nitro-modules/ios/utils/Result.hpp @@ -0,0 +1,193 @@ +#pragma once + +#include +#include +#include +#include + +namespace margelo::nitro { + +// TODO: Remove this whole Result wrapping system once Swift errors can be caught in C++. +// See https://github.com/swiftlang/swift/issues/75290 + +/** + * Represents a Result from a function. It's either a value (`T`), or an error (`std::exception_ptr`). + */ +template +class Result { +public: + // Constructors + Result(const Result& other) : _hasError(other._hasError) { + if (_hasError) { + new (&_error) std::exception_ptr(other._error); + } else { + new (&_storage) T(other.value()); + } + } + + Result(Result&& other) noexcept(std::is_nothrow_move_constructible::value) : _hasError(other._hasError) { + if (_hasError) { + new (&_error) std::exception_ptr(std::move(other._error)); + } else { + new (&_storage) T(std::move(other.value())); + } + } + + ~Result() { + destroy(); + } + + Result& operator=(const Result& other) { + if (this == &other) + return *this; + destroy(); + _hasError = other._hasError; + if (_hasError) { + new (&_error) std::exception_ptr(other._error); + } else { + new (&_storage) T(other.value()); + } + return *this; + } + + Result& operator=(Result&& other) noexcept(std::is_nothrow_move_constructible::value) { + if (this == &other) + return *this; + destroy(); + _hasError = other._hasError; + if (_hasError) { + new (&_error) std::exception_ptr(std::move(other._error)); + } else { + new (&_storage) T(std::move(other.value())); + } + return *this; + } + + // Static factories + static Result withValue(const T& value) { + return Result(value); + } + + static Result withValue(T&& value) { + return Result(std::move(value)); + } + + static Result withError(std::exception_ptr eptr) { + return Result(eptr); + } + + // Accessors + bool hasValue() const noexcept { + return !_hasError; + } + + bool hasError() const noexcept { + return _hasError; + } + + const T& value() const { + assert(!_hasError && "Result does not hold a value!"); + return *reinterpret_cast(&_storage); + } + + T& value() { + assert(!_hasError && "Result does not hold a value!"); + return *reinterpret_cast(&_storage); + } + + std::exception_ptr error() const { + assert(_hasError && "Result does not hold an error!"); + return _error; + } + +private: + // Private constructors + explicit Result(const T& value) : _hasError(false) { + new (&_storage) T(value); + } + + explicit Result(T&& value) : _hasError(false) { + new (&_storage) T(std::move(value)); + } + + explicit Result(std::exception_ptr eptr) : _hasError(true) { + new (&_error) std::exception_ptr(eptr); + } + + void destroy() { + if (_hasError) { + reinterpret_cast(&_error)->~exception_ptr(); + } else { + reinterpret_cast(&_storage)->~T(); + } + } + +private: + bool _hasError; + union { + typename std::aligned_storage::type _storage; + std::exception_ptr _error; + }; +}; + +// Specialization for void +template <> +class Result { +public: + // Constructors + Result(const Result& other) : _hasError(other._hasError), _error(other._error) {} + + Result(Result&& other) noexcept : _hasError(other._hasError), _error(std::move(other._error)) {} + + Result& operator=(const Result& other) { + if (this == &other) + return *this; + _hasError = other._hasError; + if (_hasError) { + _error = other._error; + } + return *this; + } + + Result& operator=(Result&& other) noexcept { + if (this == &other) + return *this; + _hasError = other._hasError; + if (_hasError) { + _error = std::move(other._error); + } + return *this; + } + + // Static factories + static Result withValue() { + return Result(); + } + + static Result withError(std::exception_ptr eptr) { + return Result(eptr); + } + + bool hasValue() const noexcept { + return !_hasError; + } + + bool hasError() const noexcept { + return _hasError; + } + + std::exception_ptr error() const { + assert(_hasError && "Result does not hold an error!"); + return _error; + } + +private: + explicit Result() : _hasError(false), _error(nullptr) {} + explicit Result(std::exception_ptr error) : _hasError(true), _error(error) {} + +private: + bool _hasError; + std::exception_ptr _error; +}; + +} // namespace margelo::nitro