///
/// NitroImage-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 "NitroImage-Swift-Cxx-Bridge.hpp"

// Include C++ implementation defined types
#include "HybridImageFactorySpecSwift.hpp"
#include "HybridImageLoaderFactorySpecSwift.hpp"
#include "HybridImageLoaderSpecSwift.hpp"
#include "HybridImageSpecSwift.hpp"
#include "HybridImageUtilsSpecSwift.hpp"
#include "HybridNitroImageViewSpecSwift.hpp"
#include "NitroImage-Swift-Cxx-Umbrella.hpp"
#include <NitroModules/NitroDefines.hpp>

namespace margelo::nitro::image::bridge::swift {

  // pragma MARK: std::function<void(const RawPixelData& /* result */)>
  Func_void_RawPixelData create_Func_void_RawPixelData(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void_RawPixelData::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const RawPixelData& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::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 EncodedImageData& /* result */)>
  Func_void_EncodedImageData create_Func_void_EncodedImageData(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void_EncodedImageData::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const EncodedImageData& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridImageSpec>
  std::shared_ptr<HybridImageSpec> create_std__shared_ptr_HybridImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridImageSpec_cxx swiftPart = NitroImage::HybridImageSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridImageSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridImageSpec_(std__shared_ptr_HybridImageSpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridImageSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridImageSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridImageSpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridImageSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<HybridImageSpec>& /* result */)>
  Func_void_std__shared_ptr_HybridImageSpec_ create_Func_void_std__shared_ptr_HybridImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void_std__shared_ptr_HybridImageSpec_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridImageSpec>& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void()>
  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
      swiftClosure.call();
    };
  }
  
  // pragma MARK: std::function<void(const std::string& /* result */)>
  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
      swiftClosure.call(result);
    };
  }
  
  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
    auto swiftClosure = NitroImage::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& result) mutable -> void {
      swiftClosure.call(ArrayBufferHolder(result));
    };
  }
  
  // pragma MARK: std::shared_ptr<HybridImageFactorySpec>
  std::shared_ptr<HybridImageFactorySpec> create_std__shared_ptr_HybridImageFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridImageFactorySpec_cxx swiftPart = NitroImage::HybridImageFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridImageFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridImageFactorySpec_(std__shared_ptr_HybridImageFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridImageFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridImageFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridImageFactorySpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridImageFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridNitroImageViewSpec>
  std::shared_ptr<HybridNitroImageViewSpec> create_std__shared_ptr_HybridNitroImageViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridNitroImageViewSpec_cxx swiftPart = NitroImage::HybridNitroImageViewSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridNitroImageViewSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridNitroImageViewSpec_(std__shared_ptr_HybridNitroImageViewSpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridNitroImageViewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridNitroImageViewSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridNitroImageViewSpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridNitroImageViewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridImageLoaderSpec>
  std::shared_ptr<HybridImageLoaderSpec> create_std__shared_ptr_HybridImageLoaderSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridImageLoaderSpec_cxx swiftPart = NitroImage::HybridImageLoaderSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridImageLoaderSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridImageLoaderSpec_(std__shared_ptr_HybridImageLoaderSpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridImageLoaderSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridImageLoaderSpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridImageLoaderSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridImageLoaderFactorySpec>
  std::shared_ptr<HybridImageLoaderFactorySpec> create_std__shared_ptr_HybridImageLoaderFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridImageLoaderFactorySpec_cxx swiftPart = NitroImage::HybridImageLoaderFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridImageLoaderFactorySpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridImageLoaderFactorySpec_(std__shared_ptr_HybridImageLoaderFactorySpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridImageLoaderFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridImageLoaderFactorySpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridImageLoaderFactorySpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridImageLoaderFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }
  
  // pragma MARK: std::shared_ptr<HybridImageUtilsSpec>
  std::shared_ptr<HybridImageUtilsSpec> create_std__shared_ptr_HybridImageUtilsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
    NitroImage::HybridImageUtilsSpec_cxx swiftPart = NitroImage::HybridImageUtilsSpec_cxx::fromUnsafe(swiftUnsafePointer);
    return std::make_shared<margelo::nitro::image::HybridImageUtilsSpecSwift>(swiftPart);
  }
  void* NON_NULL get_std__shared_ptr_HybridImageUtilsSpec_(std__shared_ptr_HybridImageUtilsSpec_ cppType) {
    std::shared_ptr<margelo::nitro::image::HybridImageUtilsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::image::HybridImageUtilsSpecSwift>(cppType);
    #ifdef NITRO_DEBUG
    if (swiftWrapper == nullptr) [[unlikely]] {
      throw std::runtime_error("Class \"HybridImageUtilsSpec\" is not implemented in Swift!");
    }
    #endif
    NitroImage::HybridImageUtilsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
    return swiftPart.toUnsafe();
  }

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