Using Swift with Cocoa and Objective-C (Swift 2.1)

Adopting Cocoa Design Patterns

https://developer.apple.com/library/mac/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID6

One aid in writing well-designed,resilient apps is to use Cocoa’s established design patterns. Many of these patterns rely on classes defined in Objective-C. Because of Swift’s interoperability with Objective-C,you can take advantage of these common patterns in your Swift code. In many cases,you can use Swift language features to extend or simplify existing Cocoa patterns,making them more powerful and easier to use.

Delegation

In both Swift and Objective-C,delegation is often expressed with a protocol that defines the interaction and a conforming delegate property. Just as in Objective-C,before you send a message that a delegate may not respond to,you ask the delegate whether it responds to the selector. In Swift,you can use optional chaining to invoke an optional protocol method on a possiblynilobject and unwrap the possible result usingif–letSyntax. The code listing below illustrates the following process:

Check thatmyDelegateis notnil.
Check thatmyDelegateimplements the methodwindow:willUseFullScreenContentSize:.
If 1 and 2 hold true,invoke the method and assign the result of the method to the value namedfullScreenSize.
Print the return value of the method.

class MyDelegate: NSObject, NSWindowDelegate {
func window(window: NSWindow, willUseFullScreenContentSize proposedSize: NSSize) -> NSSize {
return proposedSize
}
var myDelegate: NSWindowDelegate? = MyDelegate()
if let fullScreenSize = myDelegate?.window?(myWindow,116)"> willUseFullScreenContentSize: mySize) {
print(NSStringFromSize(fullScreenSize))
}

Lazy Initialization

Alazy propertyis a property whose underlying value is only initialized when the property is first accessed. Lazy properties are useful when the initial value for a property either requires complex or computationally expensive setup,or cannot be determined until after an instance’s initialization is complete.

In Objective-C,a property may override its synthesized getter method such that the underlying instance variable is conditionally initialized if its value isnil:

@property NSXMLDocument *XMLDocument;
- (NSXMLDocument *)XMLDocument {
if (_XMLDocument == nil) {
_XMLDocument = [[NSXMLDocument alloc] initWithContentsOfURL:[[NSBundle mainBundle] URLForResource:@"/path/to/resource" withExtension:@"xml"] options:0 error:nil];
}
return _XMLDocument;
}

In Swift,a stored property with an initial value can be declared with thelazymodifier to have the expression calculating the initial value only evaluated when the property is first accessed:

lazy var XMLDocument: NSXMLDocument = try! NSXMLDocument(contentsOfURL: NSBundle.mainBundle().URLForResource("document",116)"> withExtension: "xml")!,116)"> options: 0)

Because a lazy property is only computed when accessed for a fully-initialized instance it may access constant or variable properties in its default value initialization expression:

pattern: String

  regex:  NSRegularExpression =  NSRegularExpression(pattern:  self.pattern,116)"> options: [])

For values that require additional setup beyond initialization,you can assign the default value of the property to a self-evaluating closure that returns a fully-initialized value:

ISO8601DateFormatter: NSDateFormatter = {

 let  formatter =  NSDateFormatter()

 formatter.locale =  NSLocale(localeIdentifier:  "en_US_POSIX")

 dateFormat =  "yyyy-MM-dd'T'HH:mm:ssZZZZZ"

  formatter

}()

NOTE

If a lazy property has not yet been initialized and is accessed by more than one thread at the same time,there is no guarantee that the property will be initialized only once.

For more information,seeLazy Stored PropertiesinThe Swift Programming Language (Swift 2.1).

Error Handling

In Cocoa,methods that produce errors take anNSErrorpointer parameter as their last parameter,which populates its argument with anNSErrorobject if an error occurs. Swift automatically translates Objective-C methods that produce errors into methods that throw an error according to Swift’s native error handling functionality.

Methods thatconsumeerrors,such as delegate methods or methods that take a completion handler with anNSErrorobject argument,do not become methods that throw when imported by Swift.

For example,consider the following Objective-C method fromNSFileManager:

- (BOOL)removeItemAtURL:(NSURL *)URL
error:(NSError **)error;

removeItemAtURL(URL: NSURL) throws

Catching and Handling an Error

Here’s an example of how to handle an error when calling a method in Objective-C:

Additionally,you can usecatchclauses to match on particular error codes as a convenient way to differentiate possible failure conditions:

Converting Errors to Optional Values

NULLfor the error parameter when you only care whether there was an error,not what specific error occurred. In Swift,you writetry?to change a throwing expression into one that returns an optional value,and then check whether the value isnil.

NSFileManagerinstance methodURLForDirectory(_:inDomain:appropriateForURL:create:)returns a URL in the specified search path and domain,or produces an error if an appropriate URL does not exist and cannot be created. In Objective-C,the success or failure of the method can be determined by whether anNSURLobject is returned.

Throwing an Error

If an error occurs in an Objective-C method,that error is used to populate the error pointer argument of that method:

If Objective-C code calls a Swift method that throws an error,the error is automatically propagated to the error pointer argument of the bridged Objective-C method.

readFromFileWrapper(_:ofType:)method inNSDocument. In Objective-C,this method’s last parameter is of typeNSError **. When overriding this method in a Swift subclass ofNSDocument,the method replaces its error parameter and throws instead.

Validating Serialized Representations