//: Convenience functions/extension on top of GCD. | |
import Dispatch | |
var MainQueue: dispatch_queue_t { return dispatch_get_main_queue() } | |
func GlobalQueue(qos: dispatch_qos_class_t = .Default) -> dispatch_queue_t | |
{ | |
return dispatch_get_global_queue(qos, 0) | |
} | |
enum DispatchError: ErrorType | |
{ | |
case Timeout | |
} | |
extension dispatch_qos_class_t | |
{ | |
static var UserInteractive: dispatch_qos_class_t { return QOS_CLASS_USER_INTERACTIVE } | |
static var UserInitiated: dispatch_qos_class_t { return QOS_CLASS_USER_INITIATED } | |
static var Default: dispatch_qos_class_t { return QOS_CLASS_DEFAULT } | |
static var Utility: dispatch_qos_class_t { return QOS_CLASS_UTILITY } | |
static var Background: dispatch_qos_class_t { return QOS_CLASS_BACKGROUND } | |
static var Unspecified: dispatch_qos_class_t { return QOS_CLASS_UNSPECIFIED } | |
} | |
extension dispatch_time_t | |
{ | |
static var Now: dispatch_time_t { return DISPATCH_TIME_NOW } | |
static var Forever: dispatch_time_t { return DISPATCH_TIME_FOREVER } | |
static func After<T: IntegerType>(sec: T) -> dispatch_time_t | |
{ | |
return dispatch_time(DISPATCH_TIME_NOW, Int64(sec.toIntMax() * 1_000_000_000)) | |
} | |
static func After(sec: Double) -> dispatch_time_t | |
{ | |
return dispatch_time(DISPATCH_TIME_NOW, Int64(sec * 1_000_000_000)) | |
} | |
} | |
extension dispatch_semaphore_t | |
{ | |
final func signal() { dispatch_semaphore_signal(self) } | |
final func waitForever() | |
{ | |
let result = dispatch_semaphore_wait(self, .Forever) | |
assert(result == 0, "failed to wait on semaphore") | |
} | |
final func wait(timeout timeout: dispatch_time_t = .Forever) throws | |
{ | |
if dispatch_semaphore_wait(self, timeout) != 0 { throw DispatchError.Timeout } | |
} | |
final func with<Result>(@noescape body: Void throws -> Result) rethrows -> Result | |
{ | |
waitForever() | |
defer { signal() } | |
return try body() | |
} | |
final func with<Result>(timeout timeout: dispatch_time_t = .Forever, @noescape _ body: Void throws -> Result) throws -> Result | |
{ | |
try wait(timeout: timeout) | |
defer { signal() } | |
return try body() | |
} | |
} | |
extension dispatch_queue_t | |
{ | |
final func sync(block: dispatch_block_t) { dispatch_sync(self, block) } | |
final func async(block: dispatch_block_t) { dispatch_async(self, block) } | |
final func async(group: dispatch_group_t, _ block: dispatch_block_t) | |
{ | |
dispatch_group_async(group, self, block) | |
} | |
final func after<T: IntegerType>(sec: T, _ block: dispatch_block_t) | |
{ | |
dispatch_after(.After(sec), self, block) | |
} | |
final func after(sec: Double, _ block: dispatch_block_t) | |
{ | |
dispatch_after(.After(sec), self, block) | |
} | |
} | |
extension dispatch_group_t | |
{ | |
final func enter() { dispatch_group_enter(self) } | |
final func leave() { dispatch_group_leave(self) } | |
final func notify(queue: dispatch_queue_t, _ block: dispatch_block_t) | |
{ | |
dispatch_group_notify(self, queue, block) | |
} | |
final func waitForever() | |
{ | |
let result = dispatch_group_wait(self, .Forever) | |
assert(result == 0, "failed to wait on semaphore") | |
} | |
final func wait(timeout timeout: dispatch_time_t = .Forever) throws | |
{ | |
if dispatch_group_wait(self, timeout) != 0 { throw DispatchError.Timeout } | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment