| //===----------------------------------------------------------------------===// |
| // |
| // This source file is part of the Swift.org open source project |
| // |
| // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors |
| // Licensed under Apache License v2.0 with Runtime Library Exception |
| // |
| // See http://swift.org/LICENSE.txt for license information |
| // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| // |
| //===----------------------------------------------------------------------===// |
| |
| import CDispatch |
| |
| // This file contains declarations that are provided by the |
| // importer via Dispatch.apinote when the platform has Objective-C support |
| |
| public func dispatchMain() -> Never { |
| CDispatch.dispatch_main() |
| } |
| |
| public class DispatchObject { |
| |
| internal func wrapped() -> dispatch_object_t { |
| fatalError("should be overriden in subclass") |
| } |
| |
| public func setTarget(queue:DispatchQueue) { |
| dispatch_set_target_queue(wrapped(), queue.__wrapped) |
| } |
| |
| public func activate() { |
| dispatch_activate(wrapped()) |
| } |
| |
| public func suspend() { |
| dispatch_suspend(wrapped()) |
| } |
| |
| public func resume() { |
| dispatch_resume(wrapped()) |
| } |
| } |
| |
| |
| public class DispatchGroup : DispatchObject { |
| internal let __wrapped:dispatch_group_t; |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| public override init() { |
| __wrapped = dispatch_group_create() |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| |
| public func enter() { |
| dispatch_group_enter(__wrapped) |
| } |
| |
| public func leave() { |
| dispatch_group_leave(__wrapped) |
| } |
| } |
| |
| public class DispatchSemaphore : DispatchObject { |
| internal let __wrapped: dispatch_semaphore_t; |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| public init(value: Int) { |
| __wrapped = dispatch_semaphore_create(value) |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| } |
| |
| public class DispatchIO : DispatchObject { |
| internal let __wrapped:dispatch_io_t |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| internal init(__type: UInt, fd: Int32, queue: DispatchQueue, |
| handler: @escaping (_ error: Int32) -> Void) { |
| __wrapped = dispatch_io_create(__type, fd, queue.__wrapped, handler) |
| } |
| |
| internal init(__type: UInt, path: UnsafePointer<Int8>, oflag: Int32, |
| mode: mode_t, queue: DispatchQueue, handler: @escaping (_ error: Int32) -> Void) { |
| __wrapped = dispatch_io_create_with_path(__type, path, oflag, mode, queue.__wrapped, handler) |
| } |
| |
| internal init(__type: UInt, io: DispatchIO, |
| queue: DispatchQueue, handler: @escaping (_ error: Int32) -> Void) { |
| __wrapped = dispatch_io_create_with_io(__type, io.__wrapped, queue.__wrapped, handler) |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| |
| public func barrier(execute: @escaping () -> ()) { |
| dispatch_io_barrier(self.__wrapped, execute) |
| } |
| |
| public var fileDescriptor: Int32 { |
| return dispatch_io_get_descriptor(__wrapped) |
| } |
| |
| public func setLimit(highWater: Int) { |
| dispatch_io_set_high_water(__wrapped, highWater) |
| } |
| |
| public func setLimit(lowWater: Int) { |
| dispatch_io_set_low_water(__wrapped, lowWater) |
| } |
| } |
| |
| public class DispatchQueue : DispatchObject { |
| internal let __wrapped:dispatch_queue_t; |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| internal init(__label: String, attr: dispatch_queue_attr_t?) { |
| __wrapped = dispatch_queue_create(__label, attr) |
| } |
| |
| internal init(__label: String, attr: dispatch_queue_attr_t?, queue: DispatchQueue?) { |
| __wrapped = dispatch_queue_create_with_target(__label, attr, queue?.__wrapped) |
| } |
| |
| internal init(queue:dispatch_queue_t) { |
| __wrapped = queue |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| |
| public func sync(execute workItem: ()->()) { |
| dispatch_sync(self.__wrapped, workItem) |
| } |
| } |
| |
| public class DispatchSource : DispatchObject, |
| DispatchSourceProtocol, DispatchSourceRead, |
| DispatchSourceSignal, DispatchSourceTimer, |
| DispatchSourceUserDataAdd, DispatchSourceUserDataOr, |
| DispatchSourceUserDataReplace, DispatchSourceWrite { |
| internal let __wrapped:dispatch_source_t |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| internal init(source:dispatch_source_t) { |
| __wrapped = source |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| } |
| |
| #if HAVE_MACH |
| extension DispatchSource : DispatchSourceMachSend, |
| DispatchSourceMachReceive, DispatchSourceMemoryPressure { |
| } |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| extension DispatchSource : DispatchSourceProcess, |
| DispatchSourceFileSystemObject { |
| } |
| #endif |
| |
| internal class __DispatchData : DispatchObject { |
| internal let __wrapped:dispatch_data_t |
| |
| final internal override func wrapped() -> dispatch_object_t { |
| return unsafeBitCast(__wrapped, to: dispatch_object_t.self) |
| } |
| |
| internal init(data:dispatch_data_t, owned:Bool) { |
| __wrapped = data |
| if !owned { |
| _swift_dispatch_retain(unsafeBitCast(data, to: dispatch_object_t.self)) |
| } |
| } |
| |
| deinit { |
| _swift_dispatch_release(wrapped()) |
| } |
| } |
| |
| public typealias DispatchSourceHandler = @convention(block) () -> Void |
| |
| public protocol DispatchSourceProtocol { |
| func setEventHandler(qos: DispatchQoS, flags: DispatchWorkItemFlags, handler: DispatchSourceHandler?) |
| |
| func setEventHandler(handler: DispatchWorkItem) |
| |
| func setCancelHandler(qos: DispatchQoS, flags: DispatchWorkItemFlags, handler: DispatchSourceHandler?) |
| |
| func setCancelHandler(handler: DispatchWorkItem) |
| |
| func setRegistrationHandler(qos: DispatchQoS, flags: DispatchWorkItemFlags, handler: DispatchSourceHandler?) |
| |
| func setRegistrationHandler(handler: DispatchWorkItem) |
| |
| func cancel() |
| |
| func resume() |
| |
| func suspend() |
| |
| var handle: UInt { get } |
| |
| var mask: UInt { get } |
| |
| var data: UInt { get } |
| |
| var isCancelled: Bool { get } |
| } |
| |
| public protocol DispatchSourceUserDataAdd : DispatchSourceProtocol { |
| func add(data: UInt) |
| } |
| |
| public protocol DispatchSourceUserDataOr : DispatchSourceProtocol { |
| func or(data: UInt) |
| } |
| |
| public protocol DispatchSourceUserDataReplace : DispatchSourceProtocol { |
| func replace(data: UInt) |
| } |
| |
| #if HAVE_MACH |
| public protocol DispatchSourceMachSend : DispatchSourceProtocol { |
| public var handle: mach_port_t { get } |
| |
| public var data: DispatchSource.MachSendEvent { get } |
| |
| public var mask: DispatchSource.MachSendEvent { get } |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public protocol DispatchSourceMachReceive : DispatchSourceProtocol { |
| var handle: mach_port_t { get } |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public protocol DispatchSourceMemoryPressure : DispatchSourceProtocol { |
| public var data: DispatchSource.MemoryPressureEvent { get } |
| |
| public var mask: DispatchSource.MemoryPressureEvent { get } |
| } |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| public protocol DispatchSourceProcess : DispatchSourceProtocol { |
| var handle: pid_t { get } |
| |
| var data: DispatchSource.ProcessEvent { get } |
| |
| var mask: DispatchSource.ProcessEvent { get } |
| } |
| #endif |
| |
| public protocol DispatchSourceRead : DispatchSourceProtocol { |
| } |
| |
| public protocol DispatchSourceSignal : DispatchSourceProtocol { |
| } |
| |
| public protocol DispatchSourceTimer : DispatchSourceProtocol { |
| func scheduleOneshot(deadline: DispatchTime, leeway: DispatchTimeInterval) |
| |
| func scheduleOneshot(wallDeadline: DispatchWallTime, leeway: DispatchTimeInterval) |
| |
| func scheduleRepeating(deadline: DispatchTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval) |
| |
| func scheduleRepeating(deadline: DispatchTime, interval: Double, leeway: DispatchTimeInterval) |
| |
| func scheduleRepeating(wallDeadline: DispatchWallTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval) |
| |
| func scheduleRepeating(wallDeadline: DispatchWallTime, interval: Double, leeway: DispatchTimeInterval) |
| } |
| |
| #if !os(Linux) && !os(Android) |
| public protocol DispatchSourceFileSystemObject : DispatchSourceProtocol { |
| var handle: Int32 { get } |
| |
| var data: DispatchSource.FileSystemEvent { get } |
| |
| var mask: DispatchSource.FileSystemEvent { get } |
| } |
| #endif |
| |
| public protocol DispatchSourceWrite : DispatchSourceProtocol { |
| } |
| |
| |
| internal enum _OSQoSClass : UInt32 { |
| case QOS_CLASS_USER_INTERACTIVE = 0x21 |
| case QOS_CLASS_USER_INITIATED = 0x19 |
| case QOS_CLASS_DEFAULT = 0x15 |
| case QOS_CLASS_UTILITY = 0x11 |
| case QOS_CLASS_BACKGROUND = 0x09 |
| case QOS_CLASS_UNSPECIFIED = 0x00 |
| |
| internal init?(qosClass:dispatch_qos_class_t) { |
| switch qosClass { |
| case 0x21: self = .QOS_CLASS_USER_INTERACTIVE |
| case 0x19: self = .QOS_CLASS_USER_INITIATED |
| case 0x15: self = .QOS_CLASS_DEFAULT |
| case 0x11: self = .QOS_CLASS_UTILITY |
| case 0x09: self = .QOS_CLASS_BACKGROUND |
| case 0x00: self = .QOS_CLASS_UNSPECIFIED |
| default: return nil |
| } |
| } |
| } |
| |
| @_silgen_name("_swift_dispatch_release") |
| internal func _swift_dispatch_release(_ obj: dispatch_object_t) -> Void |
| |
| @_silgen_name("_swift_dispatch_retain") |
| internal func _swift_dispatch_retain(_ obj: dispatch_object_t) -> Void |