diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock index ac4f73ac6..2fd7d16ba 100644 --- a/example/ios/Podfile.lock +++ b/example/ios/Podfile.lock @@ -1895,7 +1895,7 @@ SPEC CHECKSUMS: glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a hermes-engine: 06a9c6900587420b90accc394199527c64259db4 NitroImage: 69ceb59dc10137ce79c49720c7405bbb61523fa5 - NitroModules: 470228966dc3549ff8c2e7e32530cfc9bf0eb6db + NitroModules: 639a4f2e08dbbeea665aa79c8106fb6b36f57fdd RCT-Folly: bf5c0376ffe4dd2cf438dcf86db385df9fdce648 RCTDeprecation: fb7d408617e25d7f537940000d766d60149c5fea RCTRequired: 9aaf0ffcc1f41f0c671af863970ef25c422a9920 diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts index b610b24d7..4b26e9fcd 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts @@ -360,8 +360,8 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> { } let __resolverCpp = __resolver.getFunctionCopy() let __rejecterCpp = ${indent(rejecterFuncBridge.parseFromSwiftToCpp('__rejecter', 'swift'), ' ')} - ${cppParameterName}.pointee.addOnResolvedListener(__resolverCpp) - ${cppParameterName}.pointee.addOnRejectedListener(__rejecterCpp) + ${cppParameterName}.addOnResolvedListener(__resolverCpp) + ${cppParameterName}.addOnRejectedListener(__rejecterCpp) return __promise }()`.trim() } else { @@ -372,12 +372,12 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> { const rejecterFunc = new FunctionType(new VoidType(), [ new NamedWrappingType('error', new ErrorType()), ]) - const addResolverName = promise.resultingType + const resolverFuncBridge = new SwiftCxxBridgedType(resolverFunc) + const rejecterFuncBridge = new SwiftCxxBridgedType(rejecterFunc) + const resolverFuncName = promise.resultingType .canBePassedByReference ? 'addOnResolvedListener' : 'addOnResolvedListenerCopy' - const resolverFuncBridge = new SwiftCxxBridgedType(resolverFunc) - const rejecterFuncBridge = new SwiftCxxBridgedType(rejecterFunc) return ` { () -> ${promise.getCode('swift')} in let __promise = ${promise.getCode('swift')}() @@ -389,8 +389,8 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> { } let __resolverCpp = ${indent(resolverFuncBridge.parseFromSwiftToCpp('__resolver', 'swift'), ' ')} let __rejecterCpp = ${indent(rejecterFuncBridge.parseFromSwiftToCpp('__rejecter', 'swift'), ' ')} - ${cppParameterName}.pointee.${addResolverName}(__resolverCpp) - ${cppParameterName}.pointee.addOnRejectedListener(__rejecterCpp) + ${cppParameterName}.${resolverFuncName}(__resolverCpp) + ${cppParameterName}.addOnRejectedListener(__rejecterCpp) return __promise }()`.trim() } @@ -662,20 +662,29 @@ case ${i}: ) switch (language) { case 'c++': - return swiftParameterName + if (this.isBridgingToDirectCppTarget) { + return swiftParameterName + } else { + return `${swiftParameterName}.getPromise()` + } case 'swift': const arg = promise.resultingType.kind === 'void' ? '' : resolvingType.parseFromSwiftToCpp('__result', 'swift') - return ` + const code = ` { () -> bridge.${bridge.specializationName} in let __promise = ${makePromise}() ${swiftParameterName} - .then({ __result in __promise.pointee.resolve(${indent(arg, ' ')}) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(${indent(arg, ' ')}) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise }()`.trim() + if (this.isBridgingToDirectCppTarget) { + return `${code}.getPromise()` + } else { + return code + } default: return swiftParameterName } diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts index ee4157d9a..d2e2af697 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts @@ -566,7 +566,7 @@ ${functions.join('\n')} function createCxxPromiseSwiftHelper(type: PromiseType): SwiftCxxHelper { const resultingType = type.resultingType.getCode('c++') const bridgedType = new SwiftCxxBridgedType(type) - const actualType = `std::shared_ptr>` + const actualType = `PromiseHolder<${resultingType}>` const resolverArgs: NamedType[] = [] if (type.resultingType.kind !== 'void') { @@ -589,17 +589,12 @@ function createCxxPromiseSwiftHelper(type: PromiseType): SwiftCxxHelper { */ using ${name} = ${actualType}; inline ${actualType} create_${name}() { - return Promise<${resultingType}>::create(); + return PromiseHolder<${resultingType}>::create(); } `.trim(), requiredIncludes: [ { - name: 'NitroModules/Promise.hpp', - space: 'system', - language: 'c++', - }, - { - name: 'memory', + name: 'NitroModules/PromiseHolder.hpp', space: 'system', language: 'c++', }, 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 d9e692f14..a82067302 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 @@ -59,6 +59,7 @@ namespace NitroImage { class HybridTestObjectSwiftKotlinSpec_cxx; } #include #include #include +#include #include #include #include @@ -282,13 +283,13 @@ namespace margelo::nitro::image::bridge::swift { return std::make_shared(value); } - // pragma MARK: std::shared_ptr> + // pragma MARK: PromiseHolder /** - * Specialized version of `std::shared_ptr>`. + * Specialized version of `PromiseHolder`. */ - using std__shared_ptr_Promise_void__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_void__() { - return Promise::create(); + using PromiseHolder_void_ = PromiseHolder; + inline PromiseHolder create_PromiseHolder_void_() { + return PromiseHolder::create(); } // pragma MARK: std::function @@ -385,13 +386,13 @@ namespace margelo::nitro::image::bridge::swift { return std::get<1>(variantWrapper.variant); } - // pragma MARK: std::shared_ptr> + // pragma MARK: PromiseHolder /** - * Specialized version of `std::shared_ptr>`. + * Specialized version of `PromiseHolder`. */ - using std__shared_ptr_Promise_int64_t__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_int64_t__() { - return Promise::create(); + using PromiseHolder_int64_t_ = PromiseHolder; + inline PromiseHolder create_PromiseHolder_int64_t_() { + return PromiseHolder::create(); } // pragma MARK: std::function @@ -422,13 +423,13 @@ namespace margelo::nitro::image::bridge::swift { return std::make_shared(value); } - // pragma MARK: std::shared_ptr> + // pragma MARK: PromiseHolder /** - * Specialized version of `std::shared_ptr>`. + * Specialized version of `PromiseHolder`. */ - using std__shared_ptr_Promise_double__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_double__() { - return Promise::create(); + using PromiseHolder_double_ = PromiseHolder; + inline PromiseHolder create_PromiseHolder_double_() { + return PromiseHolder::create(); } // pragma MARK: std::function @@ -468,13 +469,13 @@ namespace margelo::nitro::image::bridge::swift { return std::optional(value); } - // pragma MARK: std::shared_ptr> + // pragma MARK: PromiseHolder /** - * Specialized version of `std::shared_ptr>`. + * Specialized version of `PromiseHolder`. */ - using std__shared_ptr_Promise_Car__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_Car__() { - return Promise::create(); + using PromiseHolder_Car_ = PromiseHolder; + inline PromiseHolder create_PromiseHolder_Car_() { + return PromiseHolder::create(); } // pragma MARK: std::function @@ -554,18 +555,18 @@ namespace margelo::nitro::image::bridge::swift { public: explicit Func_std__shared_ptr_Promise_double___Wrapper(const std::function>()>& func): _function(func) {} explicit Func_std__shared_ptr_Promise_double___Wrapper(std::function>()>&& func): _function(std::move(func)) {} - inline std::shared_ptr> call() const { + inline PromiseHolder call() const { auto __result = _function(); return __result; } private: std::function>()> _function; } SWIFT_NONCOPYABLE; - inline Func_std__shared_ptr_Promise_double__ create_Func_std__shared_ptr_Promise_double__(void* _Nonnull closureHolder, std::shared_ptr>(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { + inline Func_std__shared_ptr_Promise_double__ create_Func_std__shared_ptr_Promise_double__(void* _Nonnull closureHolder, PromiseHolder(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { std::shared_ptr sharedClosureHolder(closureHolder, destroy); return Func_std__shared_ptr_Promise_double__([sharedClosureHolder = std::move(sharedClosureHolder), call]() -> std::shared_ptr> { auto __result = call(sharedClosureHolder.get()); - return __result; + return __result.getPromise(); }); } inline std::shared_ptr share_Func_std__shared_ptr_Promise_double__(const Func_std__shared_ptr_Promise_double__& value) { @@ -584,40 +585,40 @@ namespace margelo::nitro::image::bridge::swift { public: explicit Func_std__shared_ptr_Promise_std__string___Wrapper(const std::function>()>& func): _function(func) {} explicit Func_std__shared_ptr_Promise_std__string___Wrapper(std::function>()>&& func): _function(std::move(func)) {} - inline std::shared_ptr> call() const { + inline PromiseHolder call() const { auto __result = _function(); return __result; } private: std::function>()> _function; } SWIFT_NONCOPYABLE; - inline Func_std__shared_ptr_Promise_std__string__ create_Func_std__shared_ptr_Promise_std__string__(void* _Nonnull closureHolder, std::shared_ptr>(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { + inline Func_std__shared_ptr_Promise_std__string__ create_Func_std__shared_ptr_Promise_std__string__(void* _Nonnull closureHolder, PromiseHolder(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) { std::shared_ptr sharedClosureHolder(closureHolder, destroy); return Func_std__shared_ptr_Promise_std__string__([sharedClosureHolder = std::move(sharedClosureHolder), call]() -> std::shared_ptr> { auto __result = call(sharedClosureHolder.get()); - return __result; + return __result.getPromise(); }); } inline std::shared_ptr share_Func_std__shared_ptr_Promise_std__string__(const Func_std__shared_ptr_Promise_std__string__& value) { return std::make_shared(value); } - // pragma MARK: std::shared_ptr> + // pragma MARK: PromiseHolder /** - * Specialized version of `std::shared_ptr>`. + * Specialized version of `PromiseHolder`. */ - using std__shared_ptr_Promise_std__string__ = std::shared_ptr>; - inline std::shared_ptr> create_std__shared_ptr_Promise_std__string__() { - return Promise::create(); + using PromiseHolder_std__string_ = PromiseHolder; + inline PromiseHolder create_PromiseHolder_std__string_() { + return PromiseHolder::create(); } - // pragma MARK: std::shared_ptr>> + // pragma MARK: PromiseHolder> /** - * Specialized version of `std::shared_ptr>>`. + * Specialized version of `PromiseHolder>`. */ - using std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ = std::shared_ptr>>; - inline std::shared_ptr>> create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() { - return Promise>::create(); + using PromiseHolder_std__shared_ptr_ArrayBuffer__ = PromiseHolder>; + inline PromiseHolder> create_PromiseHolder_std__shared_ptr_ArrayBuffer__() { + return PromiseHolder>::create(); } // pragma MARK: std::function& /* result */)> 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 ee4776784..44630de74 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 @@ -538,13 +538,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { 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__() + let __resultCpp = { () -> bridge.PromiseHolder_void_ in + let __promise = bridge.create_PromiseHolder_void_() __result - .then({ __result in __promise.pointee.resolve() }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve() }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -627,13 +627,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { public func calculateFibonacciAsync(value: Double) -> bridge.Result_std__shared_ptr_Promise_int64_t___ { do { let __result = try self.__implementation.calculateFibonacciAsync(value: value) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_int64_t__ in - let __promise = bridge.create_std__shared_ptr_Promise_int64_t__() + let __resultCpp = { () -> bridge.PromiseHolder_int64_t_ in + let __promise = bridge.create_PromiseHolder_int64_t_() __result - .then({ __result in __promise.pointee.resolve(__result) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_int64_t___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -645,13 +645,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { public func wait(seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.wait(seconds: seconds) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in - let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __resultCpp = { () -> bridge.PromiseHolder_void_ in + let __promise = bridge.create_PromiseHolder_void_() __result - .then({ __result in __promise.pointee.resolve() }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve() }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -663,13 +663,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { public func promiseThrows() -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.promiseThrows() - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in - let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __resultCpp = { () -> bridge.PromiseHolder_void_ in + let __promise = bridge.create_PromiseHolder_void_() __result - .then({ __result in __promise.pointee.resolve() }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve() }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -678,7 +678,7 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { } @inline(__always) - public func awaitAndGetPromise(promise: bridge.std__shared_ptr_Promise_double__) -> bridge.Result_std__shared_ptr_Promise_double___ { + public func awaitAndGetPromise(promise: bridge.PromiseHolder_double_) -> bridge.Result_std__shared_ptr_Promise_double___ { do { let __result = try self.__implementation.awaitAndGetPromise(promise: { () -> Promise in let __promise = Promise() @@ -732,17 +732,17 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - promise.pointee.addOnResolvedListenerCopy(__resolverCpp) - promise.pointee.addOnRejectedListener(__rejecterCpp) + promise.addOnResolvedListenerCopy(__resolverCpp) + promise.addOnRejectedListener(__rejecterCpp) return __promise }()) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in - let __promise = bridge.create_std__shared_ptr_Promise_double__() + let __resultCpp = { () -> bridge.PromiseHolder_double_ in + let __promise = bridge.create_PromiseHolder_double_() __result - .then({ __result in __promise.pointee.resolve(__result) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -751,7 +751,7 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { } @inline(__always) - public func awaitAndGetComplexPromise(promise: bridge.std__shared_ptr_Promise_Car__) -> bridge.Result_std__shared_ptr_Promise_Car___ { + public func awaitAndGetComplexPromise(promise: bridge.PromiseHolder_Car_) -> bridge.Result_std__shared_ptr_Promise_Car___ { do { let __result = try self.__implementation.awaitAndGetComplexPromise(promise: { () -> Promise in let __promise = Promise() @@ -805,17 +805,17 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - promise.pointee.addOnResolvedListener(__resolverCpp) - promise.pointee.addOnRejectedListener(__rejecterCpp) + promise.addOnResolvedListener(__resolverCpp) + promise.addOnRejectedListener(__rejecterCpp) return __promise }()) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_Car__ in - let __promise = bridge.create_std__shared_ptr_Promise_Car__() + let __resultCpp = { () -> bridge.PromiseHolder_Car_ in + let __promise = bridge.create_PromiseHolder_Car_() __result - .then({ __result in __promise.pointee.resolve(__result) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_Car___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -824,7 +824,7 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { } @inline(__always) - public func awaitPromise(promise: bridge.std__shared_ptr_Promise_void__) -> bridge.Result_std__shared_ptr_Promise_void___ { + public func awaitPromise(promise: bridge.PromiseHolder_void_) -> bridge.Result_std__shared_ptr_Promise_void___ { do { let __result = try self.__implementation.awaitPromise(promise: { () -> Promise in let __promise = Promise() @@ -855,17 +855,17 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - promise.pointee.addOnResolvedListener(__resolverCpp) - promise.pointee.addOnRejectedListener(__rejecterCpp) + promise.addOnResolvedListener(__resolverCpp) + promise.addOnRejectedListener(__rejecterCpp) return __promise }()) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in - let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __resultCpp = { () -> bridge.PromiseHolder_void_ in + let __promise = bridge.create_PromiseHolder_void_() __result - .then({ __result in __promise.pointee.resolve() }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve() }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -996,19 +996,19 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - __result.pointee.addOnResolvedListenerCopy(__resolverCpp) - __result.pointee.addOnRejectedListener(__rejecterCpp) + __result.addOnResolvedListenerCopy(__resolverCpp) + __result.addOnRejectedListener(__rejecterCpp) return __promise }() } }(), n: n) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in - let __promise = bridge.create_std__shared_ptr_Promise_double__() + let __resultCpp = { () -> bridge.PromiseHolder_double_ in + let __promise = bridge.create_PromiseHolder_double_() __result - .then({ __result in __promise.pointee.resolve(__result) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -1075,19 +1075,19 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - __result.pointee.addOnResolvedListenerCopy(__resolverCpp) - __result.pointee.addOnRejectedListener(__rejecterCpp) + __result.addOnResolvedListenerCopy(__resolverCpp) + __result.addOnRejectedListener(__rejecterCpp) return __promise }() } }()) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in - let __promise = bridge.create_std__shared_ptr_Promise_double__() + let __resultCpp = { () -> bridge.PromiseHolder_double_ in + let __promise = bridge.create_PromiseHolder_double_() __result - .then({ __result in __promise.pointee.resolve(__result) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -1154,8 +1154,8 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure) }() - __result.pointee.addOnResolvedListener(__resolverCpp) - __result.pointee.addOnRejectedListener(__rejecterCpp) + __result.addOnResolvedListener(__resolverCpp) + __result.addOnRejectedListener(__rejecterCpp) return __promise }() } @@ -1165,13 +1165,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { __sharedClosure.pointee.call(std.string(__valueFromJs)) } }()) - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in - let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __resultCpp = { () -> bridge.PromiseHolder_void_ in + let __promise = bridge.create_PromiseHolder_void_() __result - .then({ __result in __promise.pointee.resolve() }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve() }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() @@ -1260,13 +1260,13 @@ public class HybridTestObjectSwiftKotlinSpec_cxx { public func createArrayBufferAsync() -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ { do { let __result = try self.__implementation.createArrayBufferAsync() - let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in - let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() + let __resultCpp = { () -> bridge.PromiseHolder_std__shared_ptr_ArrayBuffer__ in + let __promise = bridge.create_PromiseHolder_std__shared_ptr_ArrayBuffer__() __result - .then({ __result in __promise.pointee.resolve(__result.getArrayBuffer()) }) - .catch({ __error in __promise.pointee.reject(__error.toCpp()) }) + .then({ __result in __promise.resolve(__result.getArrayBuffer()) }) + .catch({ __error in __promise.reject(__error.toCpp()) }) return __promise - }() + }().getPromise() return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp) } catch (let __error) { let __exceptionPtr = __error.toCpp() diff --git a/packages/react-native-nitro-modules/NitroModules.podspec b/packages/react-native-nitro-modules/NitroModules.podspec index d697b8fc3..05093101b 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/core/PromiseHolder.hpp", "ios/utils/Result.hpp", "ios/utils/RuntimeError.hpp", "ios/utils/SwiftClosure.hpp", diff --git a/packages/react-native-nitro-modules/cpp/core/Promise.hpp b/packages/react-native-nitro-modules/cpp/core/Promise.hpp index 03084a12e..51c39596d 100644 --- a/packages/react-native-nitro-modules/cpp/core/Promise.hpp +++ b/packages/react-native-nitro-modules/cpp/core/Promise.hpp @@ -28,13 +28,9 @@ class Promise final { public: // Promise cannot be copied. Promise(const Promise&) = delete; - // Promise can be moved. - Promise(Promise&&) = default; private: - Promise() { - _mutex = std::make_unique(); - } + Promise() {} public: /** @@ -94,7 +90,7 @@ class Promise final { * Resolves this Promise with the given result, and calls any pending listeners. */ void resolve(TResult&& result) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); #ifdef NITRO_DEBUG assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE); #endif @@ -104,7 +100,7 @@ class Promise final { } } void resolve(const TResult& result) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); #ifdef NITRO_DEBUG assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE); #endif @@ -121,7 +117,7 @@ class Promise final { throw std::runtime_error("Cannot reject Promise with a null exception_ptr!"); } - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); #ifdef NITRO_DEBUG assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT); #endif @@ -137,7 +133,7 @@ class Promise final { * If the Promise is already resolved, the listener will be immediately called. */ void addOnResolvedListener(OnResolvedFunc&& onResolved) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (std::holds_alternative(_state)) { // Promise is already resolved! Call the callback immediately onResolved(std::get(_state)); @@ -147,7 +143,7 @@ class Promise final { } } void addOnResolvedListener(const OnResolvedFunc& onResolved) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (std::holds_alternative(_state)) { // Promise is already resolved! Call the callback immediately onResolved(std::get(_state)); @@ -156,15 +152,9 @@ class Promise final { _onResolvedListeners.push_back(onResolved); } } + [[deprecated("Upgrade Nitro to use PromiseHolder instead.")]] void addOnResolvedListenerCopy(const std::function& onResolved) { - std::unique_lock lock(*_mutex); - if (std::holds_alternative(_state)) { - // Promise is already resolved! Call the callback immediately - onResolved(std::get(_state)); - } else { - // Promise is not yet resolved, put the listener in our queue. - _onResolvedListeners.push_back(onResolved); - } + addOnResolvedListener([=](const TResult& value) { onResolved(value); }); } /** @@ -172,7 +162,7 @@ class Promise final { * If the Promise is already rejected, the listener will be immediately called. */ void addOnRejectedListener(OnRejectedFunc&& onRejected) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (std::holds_alternative(_state)) { // Promise is already rejected! Call the callback immediately onRejected(std::get(_state)); @@ -182,7 +172,7 @@ class Promise final { } } void addOnRejectedListener(const OnRejectedFunc& onRejected) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (std::holds_alternative(_state)) { // Promise is already rejected! Call the callback immediately onRejected(std::get(_state)); @@ -252,8 +242,8 @@ class Promise final { std::variant _state; std::vector _onResolvedListeners; std::vector _onRejectedListeners; - std::unique_ptr _mutex; -} SWIFT_NONCOPYABLE; + std::mutex _mutex; +}; // Specialization for void template <> @@ -264,12 +254,9 @@ class Promise final { public: Promise(const Promise&) = delete; - Promise(Promise&&) = default; private: - Promise() { - _mutex = std::make_unique(); - } + Promise() {} public: static std::shared_ptr create() { @@ -309,7 +296,7 @@ class Promise final { public: void resolve() { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); #ifdef NITRO_DEBUG assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE); #endif @@ -323,7 +310,7 @@ class Promise final { throw std::runtime_error("Cannot reject Promise with a null exception_ptr!"); } - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); #ifdef NITRO_DEBUG assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT); #endif @@ -335,7 +322,7 @@ class Promise final { public: void addOnResolvedListener(OnResolvedFunc&& onResolved) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (_isResolved) { onResolved(); } else { @@ -343,7 +330,7 @@ class Promise final { } } void addOnResolvedListener(const OnResolvedFunc& onResolved) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (_isResolved) { onResolved(); } else { @@ -351,7 +338,7 @@ class Promise final { } } void addOnRejectedListener(OnRejectedFunc&& onRejected) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (_error) { onRejected(_error); } else { @@ -360,7 +347,7 @@ class Promise final { } } void addOnRejectedListener(const OnRejectedFunc& onRejected) { - std::unique_lock lock(*_mutex); + std::unique_lock lock(_mutex); if (_error) { onRejected(_error); } else { @@ -400,11 +387,11 @@ class Promise final { } private: - std::unique_ptr _mutex; + std::mutex _mutex; bool _isResolved = false; std::exception_ptr _error; std::vector _onResolvedListeners; std::vector _onRejectedListeners; -} SWIFT_NONCOPYABLE; +}; } // namespace margelo::nitro diff --git a/packages/react-native-nitro-modules/ios/core/Promise.swift b/packages/react-native-nitro-modules/ios/core/Promise.swift index 1af272285..8572eee1c 100644 --- a/packages/react-native-nitro-modules/ios/core/Promise.swift +++ b/packages/react-native-nitro-modules/ios/core/Promise.swift @@ -17,16 +17,16 @@ import Foundation * - `Promise.rejected(withError:)` - Creates a new already rejected Promise. * - `Promise()` - Creates a new Promise with fully manual control over the `resolve(..)`/`reject(..)` functions. */ -public class Promise { +public final class Promise { private enum State { case result(T) case error(Error) } - + private var state: State? private var onResolvedListeners: [(T) -> Void] = [] private var onRejectedListeners: [(Error) -> Void] = [] - + /** * Create a new pending Promise. * It can (and must) be resolved **or** rejected later. @@ -34,13 +34,13 @@ public class Promise { public init() { state = nil } - + deinit { if state == nil { print("⚠️ Promise<\(String(describing: T.self))> got destroyed, but was never resolved or rejected! It is probably left hanging in JS now.") } } - + /** * Resolves this `Promise` with the given `T` and notifies all listeners. */ @@ -51,7 +51,7 @@ public class Promise { state = .result(result) onResolvedListeners.forEach { listener in listener(result) } } - + /** * Rejects this `Promise` with the given `Error` and notifies all listeners. */ @@ -76,7 +76,7 @@ extension Promise { promise.state = .result(result) return promise } - + /** * Create a new `Promise` already rejected with the given `Error`. */ @@ -85,7 +85,7 @@ extension Promise { promise.state = .error(error) return promise } - + /** * Create a new `Promise` that runs the given `async` code in a `Task`. * This does not necessarily run the code in a different Thread, but supports Swift's `async`/`await`. @@ -103,7 +103,7 @@ extension Promise { } return promise } - + /** * Create a new `Promise` that runs the given `run` function on a parallel Thread/`DispatchQueue`. */ @@ -142,7 +142,7 @@ extension Promise { } return self } - + /** * Add an error continuation listener to this `Promise`. * Once the `Promise` rejects, the `onRejectedListener` will be called with the error. diff --git a/packages/react-native-nitro-modules/ios/core/PromiseHolder.hpp b/packages/react-native-nitro-modules/ios/core/PromiseHolder.hpp new file mode 100644 index 000000000..e20959a6b --- /dev/null +++ b/packages/react-native-nitro-modules/ios/core/PromiseHolder.hpp @@ -0,0 +1,103 @@ +// +// ArrayBufferHolder.hpp +// react-native-nitro +// +// Created by Marc Rousavy on 14.08.24. +// + +#pragma once + +#include "NitroDefines.hpp" +#include "Promise.hpp" +#include +#include +#include + +namespace margelo::nitro { + +using namespace facebook; + +/** + * Holds instances of `std::shared_ptr>`. + * The reason this exists is for performance optimizations, as well as easier listeners for Swift. + */ +template +class PromiseHolder final { +public: + PromiseHolder(const std::shared_ptr>& promise) : _promise(promise) {} + PromiseHolder(std::shared_ptr>&& promise) : _promise(std::move(promise)) {} + +public: + static PromiseHolder create() { + return PromiseHolder(Promise::create()); + } + +public: + void resolve(T value) const { + _promise->resolve(std::move(value)); + } + + void reject(const std::exception_ptr& exception) const { + _promise->reject(exception); + } + +public: + void addOnResolvedListener(std::function onResolved) const { + _promise->addOnResolvedListener([onResolved = std::move(onResolved)](const T& result) { onResolved(result); }); + } + void addOnResolvedListenerCopy(std::function onResolved) const { + _promise->addOnResolvedListener([onResolved = std::move(onResolved)](const T& result) { onResolved(result); }); + } + + void addOnRejectedListener(std::function onRejected) const { + _promise->addOnRejectedListener([onRejected = std::move(onRejected)](const std::exception_ptr& error) { onRejected(error); }); + } + +public: + inline std::shared_ptr> getPromise() const { + return _promise; + } + +private: + std::shared_ptr> _promise; +}; + +template <> +class PromiseHolder final { +public: + PromiseHolder(const std::shared_ptr>& promise) : _promise(promise) {} + PromiseHolder(std::shared_ptr>&& promise) : _promise(std::move(promise)) {} + +public: + static PromiseHolder create() { + return PromiseHolder(Promise::create()); + } + +public: + void resolve() const { + _promise->resolve(); + } + + void reject(const std::exception_ptr& exception) const { + _promise->reject(exception); + } + +public: + void addOnResolvedListener(std::function onResolved) const { + _promise->addOnResolvedListener([onResolved = std::move(onResolved)]() { onResolved(); }); + } + + void addOnRejectedListener(std::function onRejected) const { + _promise->addOnRejectedListener([onRejected = std::move(onRejected)](const std::exception_ptr& error) { onRejected(error); }); + } + +public: + inline std::shared_ptr> getPromise() const { + return _promise; + } + +private: + std::shared_ptr> _promise; +}; + +} // namespace margelo::nitro