react-native-nitro-dgram 0.1.4

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

@@ -0,0 +1,302 @@
+///
+/// HybridUdpSocketDriverSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridUdpSocketDriverSpec.hpp"
+
+// Forward declaration of `HybridUdpSocketDriverSpec_cxx` to properly resolve imports.
+namespace RustCUdp { class HybridUdpSocketDriverSpec_cxx; }
+
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <functional>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <vector>
+#include <optional>
+
+#include "RustCUdp-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::udp {
+
+  /**
+   * The C++ part of HybridUdpSocketDriverSpec_cxx.swift.
+   *
+   * HybridUdpSocketDriverSpecSwift (C++) accesses HybridUdpSocketDriverSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridUdpSocketDriverSpec_cxx can directly inherit from the C++ class HybridUdpSocketDriverSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridUdpSocketDriverSpecSwift: public virtual HybridUdpSocketDriverSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridUdpSocketDriverSpecSwift(const RustCUdp::HybridUdpSocketDriverSpec_cxx& swiftPart):
+      HybridObject(HybridUdpSocketDriverSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RustCUdp::HybridUdpSocketDriverSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline double getId() noexcept override {
+      return _swiftPart.getId();
+    }
+    inline std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)> getOnMessage() noexcept override {
+      auto __result = _swiftPart.getOnMessage();
+      return __result;
+    }
+    inline void setOnMessage(const std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)>& onMessage) noexcept override {
+      _swiftPart.setOnMessage(onMessage);
+    }
+    inline std::function<void()> getOnConnect() noexcept override {
+      auto __result = _swiftPart.getOnConnect();
+      return __result;
+    }
+    inline void setOnConnect(const std::function<void()>& onConnect) noexcept override {
+      _swiftPart.setOnConnect(onConnect);
+    }
+    inline std::function<void(const std::string& /* error */)> getOnError() noexcept override {
+      auto __result = _swiftPart.getOnError();
+      return __result;
+    }
+    inline void setOnError(const std::function<void(const std::string& /* error */)>& onError) noexcept override {
+      _swiftPart.setOnError(onError);
+    }
+    inline std::function<void()> getOnClose() noexcept override {
+      auto __result = _swiftPart.getOnClose();
+      return __result;
+    }
+    inline void setOnClose(const std::function<void()>& onClose) noexcept override {
+      _swiftPart.setOnClose(onClose);
+    }
+
+  public:
+    // Methods
+    inline double bind(double port, const std::string& address, bool ipv6Only) override {
+      auto __result = _swiftPart.bind(std::forward<decltype(port)>(port), address, std::forward<decltype(ipv6Only)>(ipv6Only));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double connect(double port, const std::string& address) override {
+      auto __result = _swiftPart.connect(std::forward<decltype(port)>(port), address);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double disconnect() override {
+      auto __result = _swiftPart.disconnect();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double send(const std::shared_ptr<ArrayBuffer>& data, double port, const std::string& address) override {
+      auto __result = _swiftPart.send(ArrayBufferHolder(data), std::forward<decltype(port)>(port), address);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double sendMultiple(const std::vector<std::shared_ptr<ArrayBuffer>>& data, double port, const std::string& address) override {
+      auto __result = _swiftPart.sendMultiple(data, std::forward<decltype(port)>(port), address);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void close() override {
+      auto __result = _swiftPart.close();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline double setBroadcast(bool flag) override {
+      auto __result = _swiftPart.setBroadcast(std::forward<decltype(flag)>(flag));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setTTL(double ttl) override {
+      auto __result = _swiftPart.setTTL(std::forward<decltype(ttl)>(ttl));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setMulticastTTL(double ttl) override {
+      auto __result = _swiftPart.setMulticastTTL(std::forward<decltype(ttl)>(ttl));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setMulticastLoopback(bool flag) override {
+      auto __result = _swiftPart.setMulticastLoopback(std::forward<decltype(flag)>(flag));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setMulticastInterface(const std::string& interfaceAddress) override {
+      auto __result = _swiftPart.setMulticastInterface(interfaceAddress);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double addMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) override {
+      auto __result = _swiftPart.addMembership(multicastAddress, interfaceAddress);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double dropMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) override {
+      auto __result = _swiftPart.dropMembership(multicastAddress, interfaceAddress);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double addSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) override {
+      auto __result = _swiftPart.addSourceSpecificMembership(sourceAddress, groupAddress, interfaceAddress);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double dropSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) override {
+      auto __result = _swiftPart.dropSourceSpecificMembership(sourceAddress, groupAddress, interfaceAddress);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string getLocalAddress() override {
+      auto __result = _swiftPart.getLocalAddress();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getLocalPort() override {
+      auto __result = _swiftPart.getLocalPort();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string getRemoteAddress() override {
+      auto __result = _swiftPart.getRemoteAddress();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getRemotePort() override {
+      auto __result = _swiftPart.getRemotePort();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getRecvBufferSize() override {
+      auto __result = _swiftPart.getRecvBufferSize();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setRecvBufferSize(double size) override {
+      auto __result = _swiftPart.setRecvBufferSize(std::forward<decltype(size)>(size));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getSendBufferSize() override {
+      auto __result = _swiftPart.getSendBufferSize();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double setSendBufferSize(double size) override {
+      auto __result = _swiftPart.setSendBufferSize(std::forward<decltype(size)>(size));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getSendQueueCount() override {
+      auto __result = _swiftPart.getSendQueueCount();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double getSendQueueSize() override {
+      auto __result = _swiftPart.getSendQueueSize();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RustCUdp::HybridUdpSocketDriverSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::udp

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `() -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void {
+  public typealias bridge = margelo.nitro.udp.bridge.swift
+
+  private let closure: () -> Void
+
+  public init(_ closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> Void {
+    self.closure()
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void {
+    return Unmanaged<Func_void>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_ArrayBuffer__std__string_double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__shared_ptr_ArrayBuffer__std__string_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ data: ArrayBuffer, _ address: String, _ port: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__shared_ptr_ArrayBuffer__std__string_double {
+  public typealias bridge = margelo.nitro.udp.bridge.swift
+
+  private let closure: (_ data: ArrayBuffer, _ address: String, _ port: Double) -> Void
+
+  public init(_ closure: @escaping (_ data: ArrayBuffer, _ address: String, _ port: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(data: ArrayBuffer, address: std.string, port: Double) -> Void {
+    self.closure(data, String(address), port)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_ArrayBuffer__std__string_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_ArrayBuffer__std__string_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_ArrayBuffer__std__string_double {
+    return Unmanaged<Func_void_std__shared_ptr_ArrayBuffer__std__string_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__string.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__string.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ error: String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__string {
+  public typealias bridge = margelo.nitro.udp.bridge.swift
+
+  private let closure: (_ error: String) -> Void
+
+  public init(_ closure: @escaping (_ error: String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(error: std.string) -> Void {
+    self.closure(String(error))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
+    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridUdpDriverSpec.swift

@@ -0,0 +1,56 @@
+///
+/// HybridUdpDriverSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridUdpDriverSpec``
+public protocol HybridUdpDriverSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func createSocket(id: String?) throws -> (any HybridUdpSocketDriverSpec)
+}
+
+public extension HybridUdpDriverSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject UdpDriver]"
+  }
+}
+
+/// See ``HybridUdpDriverSpec``
+open class HybridUdpDriverSpec_base {
+  private weak var cxxWrapper: HybridUdpDriverSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridUdpDriverSpec_cxx {
+  #if DEBUG
+    guard self is HybridUdpDriverSpec else {
+      fatalError("`self` is not a `HybridUdpDriverSpec`! Did you accidentally inherit from `HybridUdpDriverSpec_base` instead of `HybridUdpDriverSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridUdpDriverSpec_cxx(self as! HybridUdpDriverSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the UdpDriver HybridObject.
+ * Implement this protocol to create Swift-based instances of UdpDriver.
+ * ```swift
+ * class HybridUdpDriver : HybridUdpDriverSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridUdpDriverSpec = HybridUdpDriverSpec_protocol & HybridUdpDriverSpec_base

package/nitrogen/generated/ios/swift/HybridUdpDriverSpec_cxx.swift

@@ -0,0 +1,141 @@
+///
+/// HybridUdpDriverSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridUdpDriverSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridUdpDriverSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::udp::bridge::swift`)
+   * from `RustCUdp-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.udp.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridUdpDriverSpec` Swift protocol.
+   */
+  private var __implementation: any HybridUdpDriverSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridUdpDriverSpec_
+
+  /**
+   * Create a new `HybridUdpDriverSpec_cxx` that wraps the given `HybridUdpDriverSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridUdpDriverSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridUdpDriverSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridUdpDriverSpec() -> any HybridUdpDriverSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridUdpDriverSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridUdpDriverSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridUdpDriverSpec_cxx {
+    return Unmanaged<HybridUdpDriverSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridUdpDriverSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridUdpDriverSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridUdpDriverSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridUdpDriverSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func createSocket(id: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_HybridUdpSocketDriverSpec__ {
+    do {
+      let __result = try self.__implementation.createSocket(id: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(id) {
+          let __unwrapped = bridge.get_std__optional_std__string_(id)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_HybridUdpSocketDriverSpec_ in
+        let __cxxWrapped = __result.getCxxWrapper()
+        return __cxxWrapped.getCxxPart()
+      }()
+      return bridge.create_Result_std__shared_ptr_HybridUdpSocketDriverSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_HybridUdpSocketDriverSpec__(__exceptionPtr)
+    }
+  }
+}