Swift-ObjC Bridging

Swift's interoperability system for seamlessly calling Objective-C code from Swift, enabling integration with existing frameworks and libraries. Critical for working with C/C++ libraries that provide Objective-C wrappers, like onnx-runtime.

Core Bridging Patterns

Error Handling Translation

Objective-C methods using NSError** parameters become throwing Swift methods:

// Objective-C
- (nullable ORTSession*)initWithEnv:(ORTEnv*)env 
                          modelPath:(NSString*)modelPath 
                              error:(NSError**)error;

// Swift (automatic bridging)
init(env: ORTEnv, modelPath: String) throws

Memory Management

• ARC Compatibility: Objective-C objects automatically memory managed
• Bridging Types: NSString ↔ String, NSArray ↔ Array, etc.
• Unsafe Access: NSMutableData provides direct memory access for performance

Optional Handling

Nullable Objective-C pointers become Swift optionals:

• nullable annotations → Optional<T>
• Non-null by default unless explicitly marked
• Implicitly unwrapped optionals for frequently-used non-null returns

Data Access Patterns

Tensor Data Bridging

Working with binary data through Objective-C frameworks:

// Get tensor data as NSMutableData
let tensorData: NSMutableData = try tensor.tensorData()

// Direct memory access
let floatPointer = tensorData.withUnsafeBytes { bytes in
    bytes.bindMemory(to: Float.self)
}

Collection Bridging

Objective-C collections bridge transparently:

• NSArray → [AnyObject] → specific Swift array types
• NSDictionary → [AnyHashable: Any] → typed dictionaries
• Set operations maintain type safety where possible

Framework Integration

Header Import

Swift automatically imports Objective-C headers:

import onnxruntime  // Imports all public Objective-C headers

Method Signature Translation

Objective-C method names convert to Swift style:

// Objective-C
- (nullable NSArray<NSString*>*)inputNamesWithError:(NSError**)error;

// Swift
func inputNames() throws -> [String]

Performance Considerations

Zero-Cost Bridging

• Value types (numbers, booleans) bridge with no overhead
• Reference types share same memory representation
• String bridging may involve copying for safety

Direct Memory Access

For performance-critical code:

// Direct access to avoid bridging overhead
tensorData.withUnsafeBytes { rawBytes in
    let floats = rawBytes.bindMemory(to: Float.self)
    // Process directly without Swift Array allocation
}

Common Patterns

Error Propagation

Objective-C errors automatically propagate as Swift exceptions:

do {
    let result = try objcMethod()
} catch {
    // Handle NSError converted to Swift Error
}

Resource Management

RAII patterns work seamlessly:

class SwiftWrapper {
    private let objcResource: ObjCClass
    
    init() throws {
        self.objcResource = try ObjCClass()
    }
    
    // objcResource automatically released when SwiftWrapper dealloc'd
}

Integration Strategies

Framework Wrapping

Creating Swift-friendly APIs over Objective-C frameworks:

1. Import Objective-C framework
2. Create Swift wrapper classes with idiomatic APIs
3. Handle error conversion and type safety
4. Provide Swift-style async/await interfaces where appropriate

Performance Optimization

• Use NSMutableData for large binary operations
• Minimize string bridging in hot paths
• Consider unsafe operations for performance-critical sections
• Cache bridged objects when possible

This bridging capability enables Swift to leverage the vast ecosystem of existing Objective-C libraries while maintaining type safety and modern language features.