react-native-nitro-dgram 0.1.4

package/nitrogen/generated/ios/swift/HybridUdpSocketDriverSpec.swift

@@ -0,0 +1,84 @@
+///
+/// HybridUdpSocketDriverSpec.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 ``HybridUdpSocketDriverSpec``
+public protocol HybridUdpSocketDriverSpec_protocol: HybridObject {
+  // Properties
+  var id: Double { get }
+  var onMessage: (_ data: ArrayBuffer, _ address: String, _ port: Double) -> Void { get set }
+  var onConnect: () -> Void { get set }
+  var onError: (_ error: String) -> Void { get set }
+  var onClose: () -> Void { get set }
+
+  // Methods
+  func bind(port: Double, address: String, ipv6Only: Bool) throws -> Double
+  func connect(port: Double, address: String) throws -> Double
+  func disconnect() throws -> Double
+  func send(data: ArrayBuffer, port: Double, address: String) throws -> Double
+  func sendMultiple(data: [ArrayBuffer], port: Double, address: String) throws -> Double
+  func close() throws -> Void
+  func setBroadcast(flag: Bool) throws -> Double
+  func setTTL(ttl: Double) throws -> Double
+  func setMulticastTTL(ttl: Double) throws -> Double
+  func setMulticastLoopback(flag: Bool) throws -> Double
+  func setMulticastInterface(interfaceAddress: String) throws -> Double
+  func addMembership(multicastAddress: String, interfaceAddress: String?) throws -> Double
+  func dropMembership(multicastAddress: String, interfaceAddress: String?) throws -> Double
+  func addSourceSpecificMembership(sourceAddress: String, groupAddress: String, interfaceAddress: String?) throws -> Double
+  func dropSourceSpecificMembership(sourceAddress: String, groupAddress: String, interfaceAddress: String?) throws -> Double
+  func getLocalAddress() throws -> String
+  func getLocalPort() throws -> Double
+  func getRemoteAddress() throws -> String
+  func getRemotePort() throws -> Double
+  func getRecvBufferSize() throws -> Double
+  func setRecvBufferSize(size: Double) throws -> Double
+  func getSendBufferSize() throws -> Double
+  func setSendBufferSize(size: Double) throws -> Double
+  func getSendQueueCount() throws -> Double
+  func getSendQueueSize() throws -> Double
+}
+
+public extension HybridUdpSocketDriverSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject UdpSocketDriver]"
+  }
+}
+
+/// See ``HybridUdpSocketDriverSpec``
+open class HybridUdpSocketDriverSpec_base {
+  private weak var cxxWrapper: HybridUdpSocketDriverSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridUdpSocketDriverSpec_cxx {
+  #if DEBUG
+    guard self is HybridUdpSocketDriverSpec else {
+      fatalError("`self` is not a `HybridUdpSocketDriverSpec`! Did you accidentally inherit from `HybridUdpSocketDriverSpec_base` instead of `HybridUdpSocketDriverSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridUdpSocketDriverSpec_cxx(self as! HybridUdpSocketDriverSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the UdpSocketDriver HybridObject.
+ * Implement this protocol to create Swift-based instances of UdpSocketDriver.
+ * ```swift
+ * class HybridUdpSocketDriver : HybridUdpSocketDriverSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridUdpSocketDriverSpec = HybridUdpSocketDriverSpec_protocol & HybridUdpSocketDriverSpec_base

package/nitrogen/generated/ios/swift/HybridUdpSocketDriverSpec_cxx.swift

@@ -0,0 +1,527 @@
+///
+/// HybridUdpSocketDriverSpec_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 HybridUdpSocketDriverSpec 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 HybridUdpSocketDriverSpec_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 `HybridUdpSocketDriverSpec` Swift protocol.
+   */
+  private var __implementation: any HybridUdpSocketDriverSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridUdpSocketDriverSpec_
+
+  /**
+   * Create a new `HybridUdpSocketDriverSpec_cxx` that wraps the given `HybridUdpSocketDriverSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridUdpSocketDriverSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridUdpSocketDriverSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridUdpSocketDriverSpec() -> any HybridUdpSocketDriverSpec {
+    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 `HybridUdpSocketDriverSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridUdpSocketDriverSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridUdpSocketDriverSpec_cxx {
+    return Unmanaged<HybridUdpSocketDriverSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridUdpSocketDriverSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridUdpSocketDriverSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridUdpSocketDriverSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridUdpSocketDriverSpec_(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
+  public final var id: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.id
+    }
+  }
+  
+  public final var onMessage: bridge.Func_void_std__shared_ptr_ArrayBuffer__std__string_double {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__shared_ptr_ArrayBuffer__std__string_double in
+        let __closureWrapper = Func_void_std__shared_ptr_ArrayBuffer__std__string_double(self.__implementation.onMessage)
+        return bridge.create_Func_void_std__shared_ptr_ArrayBuffer__std__string_double(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onMessage = { () -> (ArrayBuffer, String, Double) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__shared_ptr_ArrayBuffer__std__string_double(newValue)
+        return { (__data: ArrayBuffer, __address: String, __port: Double) -> Void in
+          __wrappedFunction.call(__data, std.string(__address), __port)
+        }
+      }()
+    }
+  }
+  
+  public final var onConnect: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onConnect)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onConnect = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+  
+  public final var onError: bridge.Func_void_std__string {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void_std__string in
+        let __closureWrapper = Func_void_std__string(self.__implementation.onError)
+        return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onError = { () -> (String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__string(newValue)
+        return { (__error: String) -> Void in
+          __wrappedFunction.call(std.string(__error))
+        }
+      }()
+    }
+  }
+  
+  public final var onClose: bridge.Func_void {
+    @inline(__always)
+    get {
+      return { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(self.__implementation.onClose)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onClose = { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(newValue)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }()
+    }
+  }
+
+  // Methods
+  @inline(__always)
+  public final func bind(port: Double, address: std.string, ipv6Only: Bool) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.bind(port: port, address: String(address), ipv6Only: ipv6Only)
+      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 final func connect(port: Double, address: std.string) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.connect(port: port, address: String(address))
+      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 final func disconnect() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.disconnect()
+      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 final func send(data: ArrayBuffer, port: Double, address: std.string) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.send(data: data, port: port, address: String(address))
+      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 final func sendMultiple(data: bridge.std__vector_std__shared_ptr_ArrayBuffer__, port: Double, address: std.string) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.sendMultiple(data: data.map({ __item in ArrayBuffer(__item) }), port: port, address: String(address))
+      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 final func close() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.close()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setBroadcast(flag: Bool) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setBroadcast(flag: flag)
+      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 final func setTTL(ttl: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setTTL(ttl: ttl)
+      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 final func setMulticastTTL(ttl: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setMulticastTTL(ttl: ttl)
+      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 final func setMulticastLoopback(flag: Bool) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setMulticastLoopback(flag: flag)
+      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 final func setMulticastInterface(interfaceAddress: std.string) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setMulticastInterface(interfaceAddress: String(interfaceAddress))
+      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 final func addMembership(multicastAddress: std.string, interfaceAddress: bridge.std__optional_std__string_) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.addMembership(multicastAddress: String(multicastAddress), interfaceAddress: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(interfaceAddress) {
+          let __unwrapped = bridge.get_std__optional_std__string_(interfaceAddress)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      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 final func dropMembership(multicastAddress: std.string, interfaceAddress: bridge.std__optional_std__string_) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.dropMembership(multicastAddress: String(multicastAddress), interfaceAddress: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(interfaceAddress) {
+          let __unwrapped = bridge.get_std__optional_std__string_(interfaceAddress)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      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 final func addSourceSpecificMembership(sourceAddress: std.string, groupAddress: std.string, interfaceAddress: bridge.std__optional_std__string_) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.addSourceSpecificMembership(sourceAddress: String(sourceAddress), groupAddress: String(groupAddress), interfaceAddress: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(interfaceAddress) {
+          let __unwrapped = bridge.get_std__optional_std__string_(interfaceAddress)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      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 final func dropSourceSpecificMembership(sourceAddress: std.string, groupAddress: std.string, interfaceAddress: bridge.std__optional_std__string_) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.dropSourceSpecificMembership(sourceAddress: String(sourceAddress), groupAddress: String(groupAddress), interfaceAddress: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(interfaceAddress) {
+          let __unwrapped = bridge.get_std__optional_std__string_(interfaceAddress)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      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 final func getLocalAddress() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getLocalAddress()
+      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 final func getLocalPort() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getLocalPort()
+      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 final func getRemoteAddress() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getRemoteAddress()
+      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 final func getRemotePort() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getRemotePort()
+      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 final func getRecvBufferSize() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getRecvBufferSize()
+      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 final func setRecvBufferSize(size: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setRecvBufferSize(size: size)
+      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 final func getSendBufferSize() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getSendBufferSize()
+      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 final func setSendBufferSize(size: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.setSendBufferSize(size: size)
+      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 final func getSendQueueCount() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getSendQueueCount()
+      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 final func getSendQueueSize() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getSendQueueSize()
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridNitroBufferSpec.cpp

@@ -0,0 +1,32 @@
+///
+/// HybridNitroBufferSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBufferSpec.hpp"
+
+namespace margelo::nitro::udp {
+
+  void HybridNitroBufferSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("alloc", &HybridNitroBufferSpec::alloc);
+      prototype.registerHybridMethod("allocUnsafe", &HybridNitroBufferSpec::allocUnsafe);
+      prototype.registerHybridMethod("byteLength", &HybridNitroBufferSpec::byteLength);
+      prototype.registerHybridMethod("write", &HybridNitroBufferSpec::write);
+      prototype.registerHybridMethod("decode", &HybridNitroBufferSpec::decode);
+      prototype.registerHybridMethod("compare", &HybridNitroBufferSpec::compare);
+      prototype.registerHybridMethod("fill", &HybridNitroBufferSpec::fill);
+      prototype.registerHybridMethod("indexOf", &HybridNitroBufferSpec::indexOf);
+      prototype.registerHybridMethod("indexOfBuffer", &HybridNitroBufferSpec::indexOfBuffer);
+      prototype.registerHybridMethod("lastIndexOfByte", &HybridNitroBufferSpec::lastIndexOfByte);
+      prototype.registerHybridMethod("lastIndexOfBuffer", &HybridNitroBufferSpec::lastIndexOfBuffer);
+      prototype.registerHybridMethod("fillBuffer", &HybridNitroBufferSpec::fillBuffer);
+    });
+  }
+
+} // namespace margelo::nitro::udp