fix: Rename TCxx to T_cxx to better hide it from user

packages/nitrogen/src/syntax/getHybridObjectName.ts

@@ -19,7 +19,7 @@ export interface HybridObjectName {
    * The name of the Swift class that bridges any types from
    * {@linkcode HybridTSpec} over to C++.
    * This includes a few type conversions or result/exception wrapping.
-   * @example "HybridImageCxx"
+   * @example "HybridImage_cxx"
    */
   HybridTSpecCxx: string
   /**
@@ -41,7 +41,7 @@ export function getHybridObjectName(
     T: hybridObjectName,
     HybridT: `Hybrid${hybridObjectName}`,
     HybridTSpec: `Hybrid${hybridObjectName}Spec`,
-    HybridTSpecCxx: `Hybrid${hybridObjectName}SpecCxx`,
+    HybridTSpecCxx: `Hybrid${hybridObjectName}Spec_cxx`,
     JHybridTSpec: `JHybrid${hybridObjectName}Spec`,
     HybridTSpecSwift: `Hybrid${hybridObjectName}SpecSwift`,
   }

packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts

@@ -312,7 +312,7 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
             return `
 { () -> ${name.HybridTSpec} in
   let __unsafePointer = ${getFunc}(${cppParameterName})
-  let __instance = ${name.HybridTSpecCxx}Unsafe.fromUnsafe(__unsafePointer)
+  let __instance = ${name.HybridTSpecCxx}.fromUnsafe(__unsafePointer)
   return __instance.get${name.HybridTSpec}()
 }()`.trim()
           default:
@@ -590,7 +590,7 @@ case ${i}:
             return `
 { () -> bridge.${bridge.specializationName} in
   let __cxxWrapped = ${name.HybridTSpecCxx}(${swiftParameterName})
-  let __pointer = ${name.HybridTSpecCxx}Unsafe.toUnsafe(__cxxWrapped)
+  let __pointer = __cxxWrapped.toUnsafe()
   return ${makeFunc}(__pointer)
 }()`.trim()
           default:

packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts

@@ -90,7 +90,7 @@ void* _Nonnull get_${name}(${name} cppType);
     cxxImplementation: {
       code: `
 ${actualType} create_${name}(void* _Nonnull swiftUnsafePointer) {
-  ${swiftPartType} swiftPart = ${swiftPartType}Unsafe::fromUnsafe(swiftUnsafePointer);
+  ${swiftPartType} swiftPart = ${swiftPartType}::fromUnsafe(swiftUnsafePointer);
   return HybridContext::getOrCreate<${swiftWrappingType}>(swiftPart);
 }
 void* _Nonnull get_${name}(${name} cppType) {
@@ -101,7 +101,7 @@ void* _Nonnull get_${name}(${name} cppType) {
   }
 #endif
   ${swiftPartType} swiftPart = swiftWrapper->getSwiftPart();
-  return ${swiftPartType}Unsafe::toUnsafe(swiftPart);
+  return swiftPart.toUnsafe();
 }
     `.trim(),
       requiredIncludes: [

packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts

@@ -48,30 +48,6 @@ ${createFileMetadataString(`${name.HybridTSpecCxx}.swift`)}
 import Foundation
 import NitroModules
 
-/**
- * Helper class for converting instances of \`${name.HybridTSpecCxx}\` from- and to unsafe pointers.
- * This is useful to pass Swift classes to C++, without having to strongly type the C++ function signature.
- * The actual Swift type can be included in the .cpp file, without having to forward-declare anything in .hpp.
- */
-public final class ${name.HybridTSpecCxx}Unsafe {
-  /**
-   * Casts a \`${name.HybridTSpecCxx}\` instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  public static func toUnsafe(_ instance: ${name.HybridTSpecCxx}) -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(instance).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a \`${name.HybridTSpecCxx}\`.
-   * The pointer has to be a retained opaque \`Unmanaged<${name.HybridTSpecCxx}>\`.
-   * This removes one strong reference from the object!
-   */
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> ${name.HybridTSpecCxx} {
-    return Unmanaged<${name.HybridTSpecCxx}>.fromOpaque(pointer).takeRetainedValue()
-  }
-}
-
 /**
  * A class implementation that bridges ${name.HybridTSpec} over to C++.
  * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
@@ -111,6 +87,23 @@ ${hasBase ? `public class ${name.HybridTSpecCxx} : ${baseClasses.join(', ')}` :
     return __implementation
   }
 
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public ${hasBase ? 'override func' : 'func'} toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a \`${name.HybridTSpecCxx}\`.
+   * The pointer has to be a retained opaque \`Unmanaged<${name.HybridTSpecCxx}>\`.
+   * This removes one strong reference from the object!
+   */
+  public ${hasBase ? 'override class func' : 'class func'} fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> ${name.HybridTSpecCxx} {
+    return Unmanaged<${name.HybridTSpecCxx}>.fromOpaque(pointer).takeRetainedValue()
+  }
+
   /**
    * Contains a (weak) reference to the C++ HybridObject to cache it.
    */

packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.cpp

@@ -20,7 +20,7 @@ namespace margelo::nitro::image::bridge::swift {
 
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridImageSpec>
   std::shared_ptr<margelo::nitro::image::HybridImageSpec> create_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(void* _Nonnull swiftUnsafePointer) {
-    NitroImage::HybridImageSpecCxx swiftPart = NitroImage::HybridImageSpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
+    NitroImage::HybridImageSpec_cxx swiftPart = NitroImage::HybridImageSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return HybridContext::getOrCreate<margelo::nitro::image::HybridImageSpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(std__shared_ptr_margelo__nitro__image__HybridImageSpec_ cppType) {
@@ -30,13 +30,13 @@ namespace margelo::nitro::image::bridge::swift {
       throw std::runtime_error("Class \"HybridImageSpec\" is not implemented in Swift!");
     }
   #endif
-    NitroImage::HybridImageSpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return NitroImage::HybridImageSpecCxxUnsafe::toUnsafe(swiftPart);
+    NitroImage::HybridImageSpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridImageFactorySpec>
   std::shared_ptr<margelo::nitro::image::HybridImageFactorySpec> create_std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_(void* _Nonnull swiftUnsafePointer) {
-    NitroImage::HybridImageFactorySpecCxx swiftPart = NitroImage::HybridImageFactorySpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
+    NitroImage::HybridImageFactorySpec_cxx swiftPart = NitroImage::HybridImageFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
     return HybridContext::getOrCreate<margelo::nitro::image::HybridImageFactorySpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_(std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_ cppType) {
@@ -46,13 +46,13 @@ namespace margelo::nitro::image::bridge::swift {
       throw std::runtime_error("Class \"HybridImageFactorySpec\" is not implemented in Swift!");
     }
   #endif
-    NitroImage::HybridImageFactorySpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return NitroImage::HybridImageFactorySpecCxxUnsafe::toUnsafe(swiftPart);
+    NitroImage::HybridImageFactorySpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>
   std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec> create_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_(void* _Nonnull swiftUnsafePointer) {
-    NitroImage::HybridTestObjectSwiftKotlinSpecCxx swiftPart = NitroImage::HybridTestObjectSwiftKotlinSpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
+    NitroImage::HybridTestObjectSwiftKotlinSpec_cxx swiftPart = NitroImage::HybridTestObjectSwiftKotlinSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return HybridContext::getOrCreate<margelo::nitro::image::HybridTestObjectSwiftKotlinSpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_(std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ cppType) {
@@ -62,13 +62,13 @@ namespace margelo::nitro::image::bridge::swift {
       throw std::runtime_error("Class \"HybridTestObjectSwiftKotlinSpec\" is not implemented in Swift!");
     }
   #endif
-    NitroImage::HybridTestObjectSwiftKotlinSpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return NitroImage::HybridTestObjectSwiftKotlinSpecCxxUnsafe::toUnsafe(swiftPart);
+    NitroImage::HybridTestObjectSwiftKotlinSpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridChildSpec>
   std::shared_ptr<margelo::nitro::image::HybridChildSpec> create_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(void* _Nonnull swiftUnsafePointer) {
-    NitroImage::HybridChildSpecCxx swiftPart = NitroImage::HybridChildSpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
+    NitroImage::HybridChildSpec_cxx swiftPart = NitroImage::HybridChildSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return HybridContext::getOrCreate<margelo::nitro::image::HybridChildSpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(std__shared_ptr_margelo__nitro__image__HybridChildSpec_ cppType) {
@@ -78,13 +78,13 @@ namespace margelo::nitro::image::bridge::swift {
       throw std::runtime_error("Class \"HybridChildSpec\" is not implemented in Swift!");
     }
   #endif
-    NitroImage::HybridChildSpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return NitroImage::HybridChildSpecCxxUnsafe::toUnsafe(swiftPart);
+    NitroImage::HybridChildSpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridBaseSpec>
   std::shared_ptr<margelo::nitro::image::HybridBaseSpec> create_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(void* _Nonnull swiftUnsafePointer) {
-    NitroImage::HybridBaseSpecCxx swiftPart = NitroImage::HybridBaseSpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
+    NitroImage::HybridBaseSpec_cxx swiftPart = NitroImage::HybridBaseSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return HybridContext::getOrCreate<margelo::nitro::image::HybridBaseSpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ cppType) {
@@ -94,8 +94,8 @@ namespace margelo::nitro::image::bridge::swift {
       throw std::runtime_error("Class \"HybridBaseSpec\" is not implemented in Swift!");
     }
   #endif
-    NitroImage::HybridBaseSpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return NitroImage::HybridBaseSpecCxxUnsafe::toUnsafe(swiftPart);
+    NitroImage::HybridBaseSpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
 } // namespace margelo::nitro::image::bridge::swift

packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp

@@ -32,16 +32,16 @@ namespace margelo::nitro::image { struct Person; }
 namespace margelo::nitro::image { enum class Powertrain; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridBaseSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridBaseSpecCxx; }
-// Forward declaration of `HybridChildSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridChildSpecCxx; }
-// Forward declaration of `HybridImageFactorySpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridImageFactorySpecCxx; }
-// Forward declaration of `HybridImageSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridImageSpecCxx; }
-// Forward declaration of `HybridTestObjectSwiftKotlinSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridTestObjectSwiftKotlinSpecCxx; }
+// Forward declaration of `HybridBaseSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridBaseSpec_cxx; }
+// Forward declaration of `HybridChildSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridChildSpec_cxx; }
+// Forward declaration of `HybridImageFactorySpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageFactorySpec_cxx; }
+// Forward declaration of `HybridImageSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageSpec_cxx; }
+// Forward declaration of `HybridTestObjectSwiftKotlinSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridTestObjectSwiftKotlinSpec_cxx; }
 
 // Include C++ defined types
 #include "Car.hpp"

packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp

@@ -71,16 +71,16 @@ namespace margelo::nitro::image { enum class Powertrain; }
 #include <NitroModules/RuntimeError.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridBaseSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridBaseSpecCxx; }
-// Forward declaration of `HybridChildSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridChildSpecCxx; }
-// Forward declaration of `HybridImageFactorySpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridImageFactorySpecCxx; }
-// Forward declaration of `HybridImageSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridImageSpecCxx; }
-// Forward declaration of `HybridTestObjectSwiftKotlinSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridTestObjectSwiftKotlinSpecCxx; }
+// Forward declaration of `HybridBaseSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridBaseSpec_cxx; }
+// Forward declaration of `HybridChildSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridChildSpec_cxx; }
+// Forward declaration of `HybridImageFactorySpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageFactorySpec_cxx; }
+// Forward declaration of `HybridImageSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageSpec_cxx; }
+// Forward declaration of `HybridTestObjectSwiftKotlinSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridTestObjectSwiftKotlinSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("NitroImage-Swift.h")

packages/react-native-nitro-image/nitrogen/generated/ios/NitroImageAutolinking.swift

@@ -10,64 +10,64 @@ public final class NitroImageAutolinking {
 
   /**
    * Creates an instance of a Swift class that implements `HybridImageFactorySpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridImageFactorySpecCxx`)
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridImageFactorySpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `HybridImageFactory`).
    */
   public static func createImageFactory() -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_ {
     let hybridObject = HybridImageFactory()
     return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_ in
-      let __cxxWrapped = HybridImageFactorySpecCxx(hybridObject)
-      let __pointer = HybridImageFactorySpecCxxUnsafe.toUnsafe(__cxxWrapped)
+      let __cxxWrapped = HybridImageFactorySpec_cxx(hybridObject)
+      let __pointer = __cxxWrapped.toUnsafe()
       return bridge.create_std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_(__pointer)
     }()
   }
 
   /**
    * Creates an instance of a Swift class that implements `HybridTestObjectSwiftKotlinSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridTestObjectSwiftKotlinSpecCxx`)
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridTestObjectSwiftKotlinSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `HybridTestObjectSwift`).
    */
   public static func createTestObjectSwiftKotlin() -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ {
     let hybridObject = HybridTestObjectSwift()
     return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ in
-      let __cxxWrapped = HybridTestObjectSwiftKotlinSpecCxx(hybridObject)
-      let __pointer = HybridTestObjectSwiftKotlinSpecCxxUnsafe.toUnsafe(__cxxWrapped)
+      let __cxxWrapped = HybridTestObjectSwiftKotlinSpec_cxx(hybridObject)
+      let __pointer = __cxxWrapped.toUnsafe()
       return bridge.create_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_(__pointer)
     }()
   }
 
   /**
    * Creates an instance of a Swift class that implements `HybridBaseSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridBaseSpecCxx`)
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridBaseSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `HybridBase`).
    */
   public static func createBase() -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ {
     let hybridObject = HybridBase()
     return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
-      let __cxxWrapped = HybridBaseSpecCxx(hybridObject)
-      let __pointer = HybridBaseSpecCxxUnsafe.toUnsafe(__cxxWrapped)
+      let __cxxWrapped = HybridBaseSpec_cxx(hybridObject)
+      let __pointer = __cxxWrapped.toUnsafe()
       return bridge.create_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(__pointer)
     }()
   }
 
   /**
    * Creates an instance of a Swift class that implements `HybridChildSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridChildSpecCxx`)
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridChildSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `HybridChild`).
    */
   public static func createChild() -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ {
     let hybridObject = HybridChild()
     return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
-      let __cxxWrapped = HybridChildSpecCxx(hybridObject)
-      let __pointer = HybridChildSpecCxxUnsafe.toUnsafe(__cxxWrapped)
+      let __cxxWrapped = HybridChildSpec_cxx(hybridObject)
+      let __pointer = __cxxWrapped.toUnsafe()
       return bridge.create_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(__pointer)
     }()
   }

packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridBaseSpecSwift.hpp

@@ -9,8 +9,8 @@
 
 #include "HybridBaseSpec.hpp"
 
-// Forward declaration of `HybridBaseSpecCxx` to properly resolve imports.
-namespace NitroImage { class HybridBaseSpecCxx; }
+// Forward declaration of `HybridBaseSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridBaseSpec_cxx; }
 
 
 
@@ -27,25 +27,25 @@ namespace NitroImage { class HybridBaseSpecCxx; }
 namespace margelo::nitro::image {
 
   /**
-   * The C++ part of HybridBaseSpecCxx.swift.
+   * The C++ part of HybridBaseSpec_cxx.swift.
    *
-   * HybridBaseSpecSwift (C++) accesses HybridBaseSpecCxx (Swift), and might
+   * HybridBaseSpecSwift (C++) accesses HybridBaseSpec_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, HybridBaseSpecCxx can directly inherit from the C++ class HybridBaseSpec
+   * the future, HybridBaseSpec_cxx can directly inherit from the C++ class HybridBaseSpec
    * to simplify the whole structure and memory management.
    */
   class HybridBaseSpecSwift: public virtual HybridBaseSpec {
   public:
     // Constructor from a Swift instance
-    explicit HybridBaseSpecSwift(const NitroImage::HybridBaseSpecCxx& swiftPart):
+    explicit HybridBaseSpecSwift(const NitroImage::HybridBaseSpec_cxx& swiftPart):
       HybridObject(HybridBaseSpec::TAG),
       _swiftPart(swiftPart) { }
 
   public:
     // Get the Swift part
-    inline NitroImage::HybridBaseSpecCxx getSwiftPart() noexcept { return _swiftPart; }
+    inline NitroImage::HybridBaseSpec_cxx getSwiftPart() noexcept { return _swiftPart; }
 
   public:
     // Get memory pressure
@@ -64,7 +64,7 @@ namespace margelo::nitro::image {
 
 
   private:
-    NitroImage::HybridBaseSpecCxx _swiftPart;
+    NitroImage::HybridBaseSpec_cxx _swiftPart;
   };
 
 } // namespace margelo::nitro::image