///
/// RustCNet-Swift-Cxx-Bridge.cpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#include "RustCNet-Swift-Cxx-Bridge.hpp"

// Include C++ implementation defined types
#include "HybridHttpParserSpecSwift.hpp"
#include "HybridNetDriverSpecSwift.hpp"
#include "HybridNetServerDriverSpecSwift.hpp"
#include "HybridNetSocketDriverSpecSwift.hpp"
#include "RustCNet-Swift-Cxx-Umbrella.hpp"
#include <NitroModules/NitroDefines.hpp>

namespace margelo::nitro::net::bridge::swift {

  // pragma MARK: std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>
  Func_void_double_std__shared_ptr_ArrayBuffer_ create_Func_void_double_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = RustCNet::Func_void_double_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](double event, const std::shared_ptr<ArrayBuffer>& data) mutable -> void {
      swiftClosure.call(event, ArrayBufferHolder(data));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridNetSocketDriverSpec>
  std::shared_ptr<HybridNetSocketDriverSpec> create_std__shared_ptr_HybridNetSocketDriverSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    RustCNet::HybridNetSocketDriverSpec_cxx swiftPart = RustCNet::HybridNetSocketDriverSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::net::HybridNetSocketDriverSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNetSocketDriverSpec_(std__shared_ptr_HybridNetSocketDriverSpec_ cppType) {
    std::shared_ptr<margelo::nitro::net::HybridNetSocketDriverSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridNetSocketDriverSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNetSocketDriverSpec\" is not implemented in Swift!");
    }
    #endif
    RustCNet::HybridNetSocketDriverSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridNetServerDriverSpec>
  std::shared_ptr<HybridNetServerDriverSpec> create_std__shared_ptr_HybridNetServerDriverSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    RustCNet::HybridNetServerDriverSpec_cxx swiftPart = RustCNet::HybridNetServerDriverSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::net::HybridNetServerDriverSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNetServerDriverSpec_(std__shared_ptr_HybridNetServerDriverSpec_ cppType) {
    std::shared_ptr<margelo::nitro::net::HybridNetServerDriverSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridNetServerDriverSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNetServerDriverSpec\" is not implemented in Swift!");
    }
    #endif
    RustCNet::HybridNetServerDriverSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridHttpParserSpec>
  std::shared_ptr<HybridHttpParserSpec> create_std__shared_ptr_HybridHttpParserSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    RustCNet::HybridHttpParserSpec_cxx swiftPart = RustCNet::HybridHttpParserSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::net::HybridHttpParserSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridHttpParserSpec_(std__shared_ptr_HybridHttpParserSpec_ cppType) {
    std::shared_ptr<margelo::nitro::net::HybridHttpParserSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridHttpParserSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridHttpParserSpec\" is not implemented in Swift!");
    }
    #endif
    RustCNet::HybridHttpParserSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
  std::shared_ptr<HybridNetDriverSpec> create_std__shared_ptr_HybridNetDriverSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    RustCNet::HybridNetDriverSpec_cxx swiftPart = RustCNet::HybridNetDriverSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::net::HybridNetDriverSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNetDriverSpec_(std__shared_ptr_HybridNetDriverSpec_ cppType) {
    std::shared_ptr<margelo::nitro::net::HybridNetDriverSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridNetDriverSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNetDriverSpec\" is not implemented in Swift!");
    }
    #endif
    RustCNet::HybridNetDriverSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

} // namespace margelo::nitro::net::bridge::swift