Interop in the real world
So far we've been going over some of the interop capabilities in Swift, but today I want to switch gears a bit and actually put this stuff to use. Along the way we'll discover some annoyances and take opportunities not available in Objective-C to remedy them.
Let's say we want to determine if a host is reachable. To do that, we . . .
The easy way
Today, let's look at Swift's implicit pointer support which can simplify our code quite a bit and works great when the callee doesn't keep the pointer alive or when it understands Objective-C and can handle retain/release/autorelease semantics. For some of the readers this will be extremely simple stuff, but I want to cover it for . . .
make the computer do the work
Improve your Xcode debugging experience with these 5 simple tips! Oh wait, I'm not selling a hocus-pocus miracle cure for cancer.  ahem
Many people are not aware of Xcode's powerful features for managing breakpoints during debugging. One such feature is the Exception breakpoint. Go to the Breakpoint navigator pane, click
+, then . . .
Compilers are Toddlers
Compilers are toddlers. You can't reason with them, you can't plead with them. They do not understand human emotions (yet) and live only in the moment. Any obstacle or failure, no matter how minor, is a complete disaster. When they expect something you fail to deliver, they complain loudly and often in front of others, creating much . . .
Unsafety? More like FUnsafety
Edit: Updated with new information to clarify that
UnsafePointer<T> expects the number of instances of
T, not the size in bytes.
Today let's discuss
UnsafePointer<T>. Perhaps you want to use a fancy function like
OSAtomicIncrement32 to keep a running counter across threads and GCD queues, without any locking, blocking, or race . . .
There is no escape, only vectors
Swift Array<T> is easily convertible to a C-style array, but much like the world of Garbage Collection, we have to be aware of object lifetimes.
A Swift Array is just a small stack-allocated header struct that points at heap-allocated memory to hold the elements. When you mutate an array, that header struct may change. If the array is . . .
While creating ThreadLocalSlot<T>, I needed to call the posix
posix_setspecific methods. Not only that, I needed to store an Objective-C object in a plain old
void*. How can we accomplish that in Swift?
The key is
Unmanaged. It contains magic sauce to let us turn an
AnyObject into a
COpaquePointer, which is . . .