react-native-ble-nitro 1.0.0-beta.9 → 1.0.0

package/nitrogen/generated/ios/BleNitro-Swift-Cxx-Bridge.cpp

@@ -9,75 +9,23 @@
 
 // Include C++ implementation defined types
 #include "BleNitro-Swift-Cxx-Umbrella.hpp"
-#include "HybridBleManagerSpecSwift.hpp"
-#include "HybridCharacteristicSpecSwift.hpp"
-#include "HybridDescriptorSpecSwift.hpp"
-#include "HybridDeviceSpecSwift.hpp"
-#include "HybridServiceSpecSwift.hpp"
+#include "HybridNativeBleNitroSpecSwift.hpp"
 
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
-  // pragma MARK: std::function<void()>
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
-      swiftClosure.call();
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
-      swiftClosure.call(error);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::optional<BleRestoredState>& /* result */)>
-  Func_void_std__optional_BleRestoredState_ create_Func_void_std__optional_BleRestoredState_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__optional_BleRestoredState_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::optional<BleRestoredState>& result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
-  // pragma MARK: std::function<void(LogLevel /* result */)>
-  Func_void_LogLevel create_Func_void_LogLevel(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_LogLevel::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](LogLevel result) mutable -> void {
-      swiftClosure.call(static_cast<int>(result));
-    };
-  }
-  
-  // pragma MARK: std::function<void(State /* result */)>
-  Func_void_State create_Func_void_State(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_State::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](State result) mutable -> void {
-      swiftClosure.call(static_cast<int>(result));
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>
-  Func_void_std__optional_NativeBleError__std__optional_NativeDevice_ create_Func_void_std__optional_NativeBleError__std__optional_NativeDevice_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__optional_NativeBleError__std__optional_NativeDevice_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::optional<NativeBleError>& error, const std::optional<NativeDevice>& scannedDevice) mutable -> void {
-      swiftClosure.call(error, scannedDevice);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const NativeDevice& /* result */)>
-  Func_void_NativeDevice create_Func_void_NativeDevice(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_NativeDevice::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const NativeDevice& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(const BLEDevice& /* device */)>
+  Func_void_BLEDevice create_Func_void_BLEDevice(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_BLEDevice::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const BLEDevice& device) mutable -> void {
+      swiftClosure.call(device);
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeDevice>& /* result */)>
-  Func_void_std__vector_NativeDevice_ create_Func_void_std__vector_NativeDevice_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__vector_NativeDevice_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeDevice>& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(bool /* success */, const std::string& /* error */)>
+  Func_void_bool_std__string create_Func_void_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_bool_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& error) mutable -> void {
+      swiftClosure.call(success, error);
     };
   }
   
@@ -89,147 +37,91 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeService>& /* result */)>
-  Func_void_std__vector_NativeService_ create_Func_void_std__vector_NativeService_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__vector_NativeService_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeService>& result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<NativeCharacteristic>& /* result */)>
-  Func_void_std__vector_NativeCharacteristic_ create_Func_void_std__vector_NativeCharacteristic_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__vector_NativeCharacteristic_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeCharacteristic>& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(const std::vector<BLEDevice>& /* devices */)>
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__vector_BLEDevice_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<BLEDevice>& devices) mutable -> void {
+      swiftClosure.call(devices);
     };
   }
   
-  // pragma MARK: std::function<void(const NativeCharacteristic& /* result */)>
-  Func_void_NativeCharacteristic create_Func_void_NativeCharacteristic(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_NativeCharacteristic::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const NativeCharacteristic& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>
+  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_bool_std__string_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& deviceId, const std::string& error) mutable -> void {
+      swiftClosure.call(success, deviceId, error);
     };
   }
   
-  // pragma MARK: std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>
-  Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_ create_Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::optional<NativeBleError>& error, const std::optional<NativeCharacteristic>& characteristic) mutable -> void {
-      swiftClosure.call(error, characteristic);
+  // pragma MARK: std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>
+  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__string_bool_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& deviceId, bool interrupted, const std::string& error) mutable -> void {
+      swiftClosure.call(deviceId, interrupted, error);
     };
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeDescriptor>& /* result */)>
-  Func_void_std__vector_NativeDescriptor_ create_Func_void_std__vector_NativeDescriptor_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__vector_NativeDescriptor_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<NativeDescriptor>& result) mutable -> void {
+  // pragma MARK: std::function<void(const std::vector<std::string>& /* result */)>
+  Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__vector_std__string_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<std::string>& result) mutable -> void {
       swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::function<void(const NativeDescriptor& /* result */)>
-  Func_void_NativeDescriptor create_Func_void_NativeDescriptor(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_NativeDescriptor::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const NativeDescriptor& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>
+  Func_void_bool_std__vector_double__std__string create_Func_void_bool_std__vector_double__std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_bool_std__vector_double__std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool success, const std::vector<double>& data, const std::string& error) mutable -> void {
+      swiftClosure.call(success, data, error);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_(void* _Nonnull swiftUnsafePointer) {
-    BleNitro::HybridBleManagerSpec_cxx swiftPart = BleNitro::HybridBleManagerSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::co::zyke::ble::HybridBleManagerSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridBleManagerSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridBleManagerSpec\" is not implemented in Swift!");
-    }
-  #endif
-    BleNitro::HybridBleManagerSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(void* _Nonnull swiftUnsafePointer) {
-    BleNitro::HybridCharacteristicSpec_cxx swiftPart = BleNitro::HybridCharacteristicSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::co::zyke::ble::HybridCharacteristicSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridCharacteristicSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridCharacteristicSpec\" is not implemented in Swift!");
-    }
-  #endif
-    BleNitro::HybridCharacteristicSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>
-  Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ create_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>
+  Func_void_std__string_std__vector_double_ create_Func_void_std__string_std__vector_double_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__string_std__vector_double_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& characteristicId, const std::vector<double>& data) mutable -> void {
+      swiftClosure.call(characteristicId, data);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(void* _Nonnull swiftUnsafePointer) {
-    BleNitro::HybridDescriptorSpec_cxx swiftPart = BleNitro::HybridDescriptorSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::co::zyke::ble::HybridDescriptorSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridDescriptorSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridDescriptorSpec\" is not implemented in Swift!");
-    }
-  #endif
-    BleNitro::HybridDescriptorSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
+  // pragma MARK: std::function<void(BLEState /* state */)>
+  Func_void_BLEState create_Func_void_BLEState(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_BLEState::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](BLEState state) mutable -> void {
+      swiftClosure.call(static_cast<int>(state));
+    };
   }
   
-  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>
-  Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ create_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& result) mutable -> void {
-      swiftClosure.call(result);
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_(void* _Nonnull swiftUnsafePointer) {
-    BleNitro::HybridDeviceSpec_cxx swiftPart = BleNitro::HybridDeviceSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::co::zyke::ble::HybridDeviceSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridDeviceSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridDeviceSpec\" is not implemented in Swift!");
-    }
-  #endif
-    BleNitro::HybridDeviceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
+      swiftClosure.call(error);
+    };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_(void* _Nonnull swiftUnsafePointer) {
-    BleNitro::HybridServiceSpec_cxx swiftPart = BleNitro::HybridServiceSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::co::zyke::ble::HybridServiceSpecSwift>(swiftPart);
+  // pragma MARK: std::shared_ptr<HybridNativeBleNitroSpec>
+  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* _Nonnull swiftUnsafePointer) {
+    BleNitro::HybridNativeBleNitroSpec_cxx swiftPart = BleNitro::HybridNativeBleNitroSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridServiceSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridServiceSpec\" is not implemented in Swift!");
+      throw std::runtime_error("Class \"HybridNativeBleNitroSpec\" is not implemented in Swift!");
     }
-  #endif
-    BleNitro::HybridServiceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    #endif
+    BleNitro::HybridNativeBleNitroSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }