0001    //
0002    //  DispatchQueue.swift
0003    //  DispatchKit <https://github.com/anpol/DispatchKit>
0004    //
0005    //  Copyright (c) 2014 Andrei Polushin. All rights reserved.
0006    //
0007    
0008    import Foundation
0009    
0010    public struct DispatchQueue
Dispatch.swift:17
        return DispatchQueue(rawValue: dispatch_get_main_queue())
Dispatch.swift:16
    public static var mainQueue: DispatchQueue {
Dispatch.swift:20
    public static var globalQueue: DispatchQueue {
Dispatch.swift:24
    public static func getGlobalQueue(priority priority: DispatchQueuePriority, flags: Int = 0) -> DispatchQueue {
Dispatch.swift:25
        return DispatchQueue(rawValue: dispatch_get_global_queue(priority.rawValue, UInt(flags)))
Dispatch.swift:28
    public static func getGlobalQueue(qosClass qosClass: DispatchQOSClass, flags: Int = 0) -> DispatchQueue {
Dispatch.swift:36
        return DispatchQueue(rawValue: dispatch_get_global_queue(identifier, UInt(flags)))
DispatchGroup.swift:55
    public func notify(queue: DispatchQueue, block: dispatch_block_t) {
DispatchIO.swift:32
         queue: DispatchQueue? = nil, cleanup: CleanupHandler! = nil) {
DispatchIO.swift:43
         queue: DispatchQueue? = nil, cleanup: CleanupHandler! = nil) {
DispatchIO.swift:54
         queue: DispatchQueue? = nil, cleanup: CleanupHandler! = nil) {
DispatchIO.swift:65
                        queue: DispatchQueue, handler: (DispatchData<T>!, Int) -> Void) {
DispatchIO.swift:74
                         queue: DispatchQueue, handler: (DispatchData<T>!, Int) -> Void) {
DispatchIO.swift:84
                 queue: DispatchQueue, handler: (Bool, DispatchData<T>!, Int) -> Void) {
DispatchIO.swift:93
                  queue: DispatchQueue, handler: (Bool, DispatchData<T>!, Int) -> Void) {
DispatchQueue.swift:90
    public func setTargetQueue(targetQueue: DispatchQueue?) {
DispatchQueueSpecific.swift:10
public extension DispatchQueue {
DispatchSource.swift:28
    public init!(_ type: DispatchSourceType, handle: UInt = 0, mask: UInt = 0, queue: DispatchQueue) {
 : DispatchObject, DispatchResumable {
0011    
0012        @available(*, unavailable, renamed="rawValue")
0013        public var queue: dispatch_queue_t {
0014            return rawValue
0015        }
0016    
0017        @available(*, unavailable, renamed="DispatchQueue(rawValue:)")
0018        public init(raw queue: dispatch_queue_t) {
0019            self.rawValue = queue
0020        }
0021    
0022        public let rawValue
DispatchGroup.swift:56
        dispatch_group_notify(rawValue, queue.rawValue, block)
DispatchIO.swift:34
        guard let rawValue = dispatch_io_create(type.rawValue, fd, queue?.rawValue, cleanup) else {
DispatchIO.swift:45
        guard let rawValue = dispatch_io_create_with_path(type.rawValue, path, oflag, mode, queue?.rawValue, cleanup) else {
DispatchIO.swift:56
        guard let rawValue = dispatch_io_create_with_io(type.rawValue, io.rawValue, queue?.rawValue, cleanup) else {
DispatchIO.swift:67
        dispatch_read(fd, length, queue.rawValue) {
DispatchIO.swift:76
        dispatch_write(fd, data.rawValue, queue.rawValue) {
DispatchIO.swift:86
        dispatch_io_read(rawValue, offset, length, queue.rawValue) {
DispatchIO.swift:95
        dispatch_io_write(rawValue, offset, data.rawValue, queue.rawValue) {
DispatchQueue.swift:25
        self.rawValue = rawValue
DispatchQueue.swift:40
            self.rawValue = rawValue
DispatchQueue.swift:51
            self.rawValue = rawValue
DispatchQueue.swift:57
            self.rawValue = rawValue
DispatchQueue.swift:68
        return dispatch_queue_get_label(rawValue)
DispatchQueue.swift:92
        dispatch_set_target_queue(rawValue, targetQueue?.rawValue)
DispatchQueue.swift:92
        dispatch_set_target_queue(rawValue, targetQueue?.rawValue)
DispatchQueue.swift:97
        dispatch_suspend(rawValue)
DispatchQueue.swift:101
        dispatch_resume(rawValue)
DispatchQueue.swift:106
        dispatch_sync(rawValue, block)
DispatchQueue.swift:111
        dispatch_barrier_sync(rawValue, block)
DispatchQueue.swift:115
        dispatch_apply(iterations, rawValue, { block($0) })
DispatchQueue.swift:120
        dispatch_async(rawValue, block)
DispatchQueue.swift:124
        dispatch_group_async(group.rawValue, rawValue, block)
DispatchQueue.swift:129
        dispatch_barrier_async(rawValue, block)
DispatchQueue.swift:134
        dispatch_after(when.rawValue, rawValue, block)
DispatchQueueSpecific.swift:12
        let specific = dispatch_queue_get_specific(rawValue, key)
DispatchQueueSpecific.swift:17
        dispatch_queue_set_specific(rawValue, key, dk_passRetained(specific), dk_release)
DispatchSource.swift:29
        guard let rawValue = dispatch_source_create(type.toOpaque(), handle, mask, queue.rawValue) else {
: dispatch_queue_t
0023    
0024        public init
Dispatch.swift:17
        return DispatchQueue(rawValue: dispatch_get_main_queue())
Dispatch.swift:25
        return DispatchQueue(rawValue: dispatch_get_global_queue(priority.rawValue, UInt(flags)))
Dispatch.swift:36
        return DispatchQueue(rawValue: dispatch_get_global_queue(identifier, UInt(flags)))
(rawValue: dispatch_queue_t) {
0025            self.rawValue = rawValue
0026        }
0027    
0028        public init!(_ label: String! = nil,
0029                    attr: DispatchQueueAttr = .Serial,
0030                    qosClass: DispatchQOSClass = .Unspecified,
0031                    relativePriority: Int = 0) {
0032            assert(Int(QOS_MIN_RELATIVE_PRIORITY)...0 ~= relativePriority,
0033                   "Invalid parameter: relative_priority")
0034    
0035            if qosClass == .Unspecified {
0036                guard let rawValue = dispatch_queue_create(label, attr.rawValue) else {
0037                    return nil
0038                }
0039    
0040                self.rawValue = rawValue
0041            } else if #available(iOS 8.0, *) {
0042                // iOS 8 and later: apply QOS class
0043                guard
0044                    let qosAttr = dispatch_queue_attr_make_with_qos_class(
0045                        attr.rawValue, qosClass.rawClass, Int32(relativePriority)),
0046                    let rawValue = dispatch_queue_create(label, qosAttr)
0047                else {
0048                    return nil
0049                }
0050    
0051                self.rawValue = rawValue
0052            } else {
0053                guard let rawValue = dispatch_queue_create(label, attr.rawValue) else {
0054                    return nil
0055                }
0056    
0057                self.rawValue = rawValue
0058    
0059                // iOS 7 and earlier: simulate QOS class by applying a target queue.
0060                let priority = DispatchQueuePriority(qosClass: qosClass)
0061                let target = dispatch_get_global_queue(priority.rawValue, 0)
0062                dispatch_set_target_queue(rawValue, target)
0063            }
0064        }
0065    
0066        public var clabel
DispatchQueue.swift:72
        let (s, _) = String.fromCStringRepairingIllFormedUTF8(clabel)
: UnsafePointer<CChar> {
0067            // this function never returns NULL, despite its documentation.
0068            return dispatch_queue_get_label(rawValue)
0069        }
0070    
0071        public var label
DispatchQueue.swift:78
        return label == "com.apple.main-thread"
DispatchQueue.swift:82
        return label.hasPrefix("com.apple.root.")
DispatchQueue.swift:86
        return label.hasPrefix("com.apple.")
: String {
0072            let (s, _) = String.fromCStringRepairingIllFormedUTF8(clabel)
0073            return s ?? "(null)"
0074        }
0075    
0076    
0077        public var isMainQueue: Bool {
0078            return label == "com.apple.main-thread"
0079        }
0080    
0081        public var isGlobalQueue: Bool {
0082            return label.hasPrefix("com.apple.root.")
0083        }
0084    
0085        public var isSystemQueue
DispatchQueue.swift:91
        assert(!isSystemQueue)
DispatchQueue.swift:110
        assert(!isSystemQueue)
DispatchQueue.swift:128
        assert(!isSystemQueue)
: Bool {
0086            return label.hasPrefix("com.apple.")
0087        }
0088    
0089        // NOTE set to nil to reset target queue to default
0090        public func setTargetQueue(targetQueue: DispatchQueue?) {
0091            assert(!isSystemQueue)
0092            dispatch_set_target_queue(rawValue, targetQueue?.rawValue)
0093        }
0094    
0095    
0096        public func suspend() {
0097            dispatch_suspend(rawValue)
0098        }
0099    
0100        public func resume() {
0101            dispatch_resume(rawValue)
0102        }
0103    
0104    
0105        public func sync(block: dispatch_block_t) {
0106            dispatch_sync(rawValue, block)
0107        }
0108    
0109        public func barrierSync(block: dispatch_block_t) {
0110            assert(!isSystemQueue)
0111            dispatch_barrier_sync(rawValue, block)
0112        }
0113    
0114        public func apply(iterations: Int, block: (Int) -> Void) {
0115            dispatch_apply(iterations, rawValue, { block($0) })
0116        }
0117    
0118    
0119        public func async(block: dispatch_block_t) {
0120            dispatch_async(rawValue, block)
0121        }
0122    
0123        public func async(group: DispatchGroup, block: dispatch_block_t) {
0124            dispatch_group_async(group.rawValue, rawValue, block)
0125        }
0126    
0127        public func barrierAsync(block: dispatch_block_t) {
0128            assert(!isSystemQueue)
0129            dispatch_barrier_async(rawValue, block)
0130        }
0131    
0132    
0133        public func after(when: DispatchTime, block: dispatch_block_t) {
0134            dispatch_after(when.rawValue, rawValue, block)
0135        }
0136    
0137    }
0138    
0139    public struct DispatchCurrentQueue
Dispatch.swift:13
        return DispatchCurrentQueue()
Dispatch.swift:12
    public static var currentQueue: DispatchCurrentQueue {
DispatchQueueSpecific.swift:21
public extension DispatchCurrentQueue {
 {
0140        public var clabel
DispatchQueue.swift:145
        let (s, _) = String.fromCStringRepairingIllFormedUTF8(clabel)
: UnsafePointer<CChar> {
0141            return dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL)
0142        }
0143    
0144        public var label: String {
0145            let (s, _) = String.fromCStringRepairingIllFormedUTF8(clabel)
0146            return s ?? "(null)"
0147        }
0148    }
0149