| //===----------------------------------------------------------------------===// |
| // |
| // 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 |
| |
| public extension DispatchSourceProtocol { |
| |
| public func setEventHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) { |
| if #available(OSX 10.10, iOS 8.0, *), let h = handler, qos != .unspecified || !flags.isEmpty { |
| let item = DispatchWorkItem(qos: qos, flags: flags, block: h) |
| CDispatch.dispatch_source_set_event_handler((self as! DispatchSource).__wrapped, item._block) |
| } else { |
| CDispatch.dispatch_source_set_event_handler((self as! DispatchSource).__wrapped, handler) |
| } |
| } |
| |
| @available(OSX 10.10, iOS 8.0, *) |
| public func setEventHandler(handler: DispatchWorkItem) { |
| CDispatch.dispatch_source_set_event_handler((self as! DispatchSource).__wrapped, handler._block) |
| } |
| |
| public func setCancelHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) { |
| if #available(OSX 10.10, iOS 8.0, *), let h = handler, qos != .unspecified || !flags.isEmpty { |
| let item = DispatchWorkItem(qos: qos, flags: flags, block: h) |
| CDispatch.dispatch_source_set_cancel_handler((self as! DispatchSource).__wrapped, item._block) |
| } else { |
| CDispatch.dispatch_source_set_cancel_handler((self as! DispatchSource).__wrapped, handler) |
| } |
| } |
| |
| @available(OSX 10.10, iOS 8.0, *) |
| public func setCancelHandler(handler: DispatchWorkItem) { |
| CDispatch.dispatch_source_set_cancel_handler((self as! DispatchSource).__wrapped, handler._block) |
| } |
| |
| public func setRegistrationHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) { |
| if #available(OSX 10.10, iOS 8.0, *), let h = handler, qos != .unspecified || !flags.isEmpty { |
| let item = DispatchWorkItem(qos: qos, flags: flags, block: h) |
| CDispatch.dispatch_source_set_registration_handler((self as! DispatchSource).__wrapped, item._block) |
| } else { |
| CDispatch.dispatch_source_set_registration_handler((self as! DispatchSource).__wrapped, handler) |
| } |
| } |
| |
| @available(OSX 10.10, iOS 8.0, *) |
| public func setRegistrationHandler(handler: DispatchWorkItem) { |
| CDispatch.dispatch_source_set_registration_handler((self as! DispatchSource).__wrapped, handler._block) |
| } |
| |
| @available(OSX 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *) |
| public func activate() { |
| (self as! DispatchSource).activate() |
| } |
| |
| public func cancel() { |
| CDispatch.dispatch_source_cancel((self as! DispatchSource).__wrapped) |
| } |
| |
| public func resume() { |
| (self as! DispatchSource).resume() |
| } |
| |
| public func suspend() { |
| (self as! DispatchSource).suspend() |
| } |
| |
| public var handle: UInt { |
| return CDispatch.dispatch_source_get_handle((self as! DispatchSource).__wrapped) |
| } |
| |
| public var mask: UInt { |
| return CDispatch.dispatch_source_get_mask((self as! DispatchSource).__wrapped) |
| } |
| |
| public var data: UInt { |
| return CDispatch.dispatch_source_get_data((self as! DispatchSource).__wrapped) |
| } |
| |
| public var isCancelled: Bool { |
| return CDispatch.dispatch_source_testcancel((self as! DispatchSource).__wrapped) != 0 |
| } |
| } |
| |
| public extension DispatchSource { |
| #if HAVE_MACH |
| public struct MachSendEvent : OptionSet, RawRepresentable { |
| public let rawValue: UInt |
| public init(rawValue: UInt) { self.rawValue = rawValue } |
| |
| public static let dead = MachSendEvent(rawValue: 0x1) |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public struct MemoryPressureEvent : OptionSet, RawRepresentable { |
| public let rawValue: UInt |
| public init(rawValue: UInt) { self.rawValue = rawValue } |
| |
| public static let normal = MemoryPressureEvent(rawValue: 0x1) |
| public static let warning = MemoryPressureEvent(rawValue: 0x2) |
| public static let critical = MemoryPressureEvent(rawValue: 0x4) |
| public static let all: MemoryPressureEvent = [.normal, .warning, .critical] |
| } |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| public struct ProcessEvent : OptionSet, RawRepresentable { |
| public let rawValue: UInt |
| public init(rawValue: UInt) { self.rawValue = rawValue } |
| |
| public static let exit = ProcessEvent(rawValue: 0x80000000) |
| public static let fork = ProcessEvent(rawValue: 0x40000000) |
| public static let exec = ProcessEvent(rawValue: 0x20000000) |
| public static let signal = ProcessEvent(rawValue: 0x08000000) |
| public static let all: ProcessEvent = [.exit, .fork, .exec, .signal] |
| } |
| #endif |
| |
| public struct TimerFlags : OptionSet, RawRepresentable { |
| public let rawValue: UInt |
| public init(rawValue: UInt) { self.rawValue = rawValue } |
| |
| public static let strict = TimerFlags(rawValue: 1) |
| } |
| |
| public struct FileSystemEvent : OptionSet, RawRepresentable { |
| public let rawValue: UInt |
| public init(rawValue: UInt) { self.rawValue = rawValue } |
| |
| public static let delete = FileSystemEvent(rawValue: 0x1) |
| public static let write = FileSystemEvent(rawValue: 0x2) |
| public static let extend = FileSystemEvent(rawValue: 0x4) |
| public static let attrib = FileSystemEvent(rawValue: 0x8) |
| public static let link = FileSystemEvent(rawValue: 0x10) |
| public static let rename = FileSystemEvent(rawValue: 0x20) |
| public static let revoke = FileSystemEvent(rawValue: 0x40) |
| public static let funlock = FileSystemEvent(rawValue: 0x100) |
| |
| public static let all: FileSystemEvent = [ |
| .delete, .write, .extend, .attrib, .link, .rename, .revoke] |
| } |
| |
| #if HAVE_MACH |
| public class func makeMachSendSource(port: mach_port_t, eventMask: MachSendEvent, queue: DispatchQueue? = nil) -> DispatchSourceMachSend { |
| let source = dispatch_source_create(_swift_dispatch_source_type_mach_send(), UInt(port), eventMask.rawValue, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceMachSend |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public class func makeMachReceiveSource(port: mach_port_t, queue: DispatchQueue? = nil) -> DispatchSourceMachReceive { |
| let source = dispatch_source_create(_swift_dispatch_source_type_mach_recv(), UInt(port), 0, queue?.__wrapped) |
| return DispatchSource(source) as DispatchSourceMachReceive |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public class func makeMemoryPressureSource(eventMask: MemoryPressureEvent, queue: DispatchQueue? = nil) -> DispatchSourceMemoryPressure { |
| let source = dispatch_source_create(_swift_dispatch_source_type_memorypressure(), 0, eventMask.rawValue, queue.__wrapped) |
| return DispatchSourceMemoryPressure(source) |
| } |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| public class func makeProcessSource(identifier: pid_t, eventMask: ProcessEvent, queue: DispatchQueue? = nil) -> DispatchSourceProcess { |
| let source = dispatch_source_create(_swift_dispatch_source_type_proc(), UInt(identifier), eventMask.rawValue, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceProcess |
| } |
| #endif |
| |
| public class func makeReadSource(fileDescriptor: Int32, queue: DispatchQueue? = nil) -> DispatchSourceRead { |
| let source = dispatch_source_create(_swift_dispatch_source_type_read(), UInt(fileDescriptor), 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceRead |
| } |
| |
| public class func makeSignalSource(signal: Int32, queue: DispatchQueue? = nil) -> DispatchSourceSignal { |
| let source = dispatch_source_create(_swift_dispatch_source_type_signal(), UInt(signal), 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceSignal |
| } |
| |
| public class func makeTimerSource(flags: TimerFlags = [], queue: DispatchQueue? = nil) -> DispatchSourceTimer { |
| let source = dispatch_source_create(_swift_dispatch_source_type_timer(), 0, flags.rawValue, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceTimer |
| } |
| |
| public class func makeUserDataAddSource(queue: DispatchQueue? = nil) -> DispatchSourceUserDataAdd { |
| let source = dispatch_source_create(_swift_dispatch_source_type_data_add(), 0, 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceUserDataAdd |
| } |
| |
| public class func makeUserDataOrSource(queue: DispatchQueue? = nil) -> DispatchSourceUserDataOr { |
| let source = dispatch_source_create(_swift_dispatch_source_type_data_or(), 0, 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceUserDataOr |
| } |
| |
| public class func makeUserDataReplaceSource(queue: DispatchQueue? = nil) -> DispatchSourceUserDataReplace { |
| let source = dispatch_source_create(_swift_dispatch_source_type_data_replace(), 0, 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceUserDataReplace |
| } |
| |
| #if !os(Linux) && !os(Android) |
| public class func makeFileSystemObjectSource(fileDescriptor: Int32, eventMask: FileSystemEvent, queue: DispatchQueue? = nil) -> DispatchSourceFileSystemObject { |
| let source = dispatch_source_create(_swift_dispatch_source_type_vnode(), UInt(fileDescriptor), eventMask.rawValue, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceFileSystemObject |
| } |
| #endif |
| |
| public class func makeWriteSource(fileDescriptor: Int32, queue: DispatchQueue? = nil) -> DispatchSourceWrite { |
| let source = dispatch_source_create(_swift_dispatch_source_type_write(), UInt(fileDescriptor), 0, queue?.__wrapped) |
| return DispatchSource(source: source) as DispatchSourceWrite |
| } |
| } |
| |
| #if HAVE_MACH |
| public extension DispatchSourceMachSend { |
| public var handle: mach_port_t { |
| return mach_port_t(dispatch_source_get_handle(self as! DispatchSource)) |
| } |
| |
| public var data: DispatchSource.MachSendEvent { |
| let data = dispatch_source_get_data(self as! DispatchSource) |
| return DispatchSource.MachSendEvent(rawValue: data) |
| } |
| |
| public var mask: DispatchSource.MachSendEvent { |
| let mask = dispatch_source_get_mask(self as! DispatchSource) |
| return DispatchSource.MachSendEvent(rawValue: mask) |
| } |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public extension DispatchSourceMachReceive { |
| public var handle: mach_port_t { |
| return mach_port_t(dispatch_source_get_handle(self as! DispatchSource)) |
| } |
| } |
| #endif |
| |
| #if HAVE_MACH |
| public extension DispatchSourceMemoryPressure { |
| public var data: DispatchSource.MemoryPressureEvent { |
| let data = dispatch_source_get_data(self as! DispatchSource) |
| return DispatchSource.MemoryPressureEvent(rawValue: data) |
| } |
| |
| public var mask: DispatchSource.MemoryPressureEvent { |
| let mask = dispatch_source_get_mask(self as! DispatchSource) |
| return DispatchSource.MemoryPressureEvent(rawValue: mask) |
| } |
| } |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| public extension DispatchSourceProcess { |
| public var handle: pid_t { |
| return pid_t(dispatch_source_get_handle(self as! DispatchSource)) |
| } |
| |
| public var data: DispatchSource.ProcessEvent { |
| let data = dispatch_source_get_data(self as! DispatchSource) |
| return DispatchSource.ProcessEvent(rawValue: data) |
| } |
| |
| public var mask: DispatchSource.ProcessEvent { |
| let mask = dispatch_source_get_mask(self as! DispatchSource) |
| return DispatchSource.ProcessEvent(rawValue: mask) |
| } |
| } |
| #endif |
| |
| public extension DispatchSourceTimer { |
| /// |
| /// Sets the deadline and leeway for a timer event that fires once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared and the next timer event will occur at `deadline`. |
| /// |
| /// Delivery of the timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// - note: Delivery of the timer event does not cancel the timer source. |
| /// |
| /// - parameter deadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on Mach absolute |
| /// time. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(deadline:repeating:leeway:)") |
| public func scheduleOneshot(deadline: DispatchTime, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, ~0, UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline and leeway for a timer event that fires once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared and the next timer event will occur at `wallDeadline`. |
| /// |
| /// Delivery of the timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// - note: Delivery of the timer event does not cancel the timer source. |
| /// |
| /// - parameter wallDeadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on |
| /// `gettimeofday(3)`. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(wallDeadline:repeating:leeway:)") |
| public func scheduleOneshot(wallDeadline: DispatchWallTime, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, ~0, UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, interval and leeway for a timer event that fires at least once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `deadline` and every `interval` units of |
| /// time thereafter until the timer source is canceled. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `deadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `deadline + N * interval`, the upper |
| /// limit is the smaller of `leeway` and `interval/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter deadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on Mach absolute |
| /// time. |
| /// - parameter interval: the interval for the timer. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(deadline:repeating:leeway:)") |
| public func scheduleRepeating(deadline: DispatchTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, interval == .never ? ~0 : UInt64(interval.rawValue), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, interval and leeway for a timer event that fires at least once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `deadline` and every `interval` seconds |
| /// thereafter until the timer source is canceled. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption and |
| /// system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `deadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `deadline + N * interval`, the upper |
| /// limit is the smaller of `leeway` and `interval/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter deadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on Mach absolute |
| /// time. |
| /// - parameter interval: the interval for the timer in seconds. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(deadline:repeating:leeway:)") |
| public func scheduleRepeating(deadline: DispatchTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, interval.isInfinite ? ~0 : UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, interval and leeway for a timer event that fires at least once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `wallDeadline` and every `interval` units of |
| /// time thereafter until the timer source is canceled. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption and |
| /// system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `wallDeadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `wallDeadline + N * interval`, the upper |
| /// limit is the smaller of `leeway` and `interval/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter wallDeadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on |
| /// `gettimeofday(3)`. |
| /// - parameter interval: the interval for the timer. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(wallDeadline:repeating:leeway:)") |
| public func scheduleRepeating(wallDeadline: DispatchWallTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval == .never ? ~0 : UInt64(interval.rawValue), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, interval and leeway for a timer event that fires at least once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `wallDeadline` and every `interval` seconds |
| /// thereafter until the timer source is canceled. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption and |
| /// system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `wallDeadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `wallDeadline + N * interval`, the upper |
| /// limit is the smaller of `leeway` and `interval/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter wallDeadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on |
| /// `gettimeofday(3)`. |
| /// - parameter interval: the interval for the timer in seconds. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, deprecated: 4, renamed: "schedule(wallDeadline:repeating:leeway:)") |
| public func scheduleRepeating(wallDeadline: DispatchWallTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval.isInfinite ? ~0 : UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, repeat interval and leeway for a timer event. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `deadline` and every `repeating` units of |
| /// time thereafter until the timer source is canceled. If the value of `repeating` is `.never`, |
| /// or is defaulted, the timer fires only once. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `deadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `deadline + N * repeating`, the upper |
| /// limit is the smaller of `leeway` and `repeating/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter deadline: the time at which the first timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on Mach absolute |
| /// time. |
| /// - parameter repeating: the repeat interval for the timer, or `.never` if the timer should fire |
| /// only once. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, introduced: 4) |
| public func schedule(deadline: DispatchTime, repeating interval: DispatchTimeInterval = .never, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, interval == .never ? ~0 : UInt64(interval.rawValue), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, repeat interval and leeway for a timer event. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `deadline` and every `repeating` seconds |
| /// thereafter until the timer source is canceled. If the value of `repeating` is `.infinity`, |
| /// the timer fires only once. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `deadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `deadline + N * repeating`, the upper |
| /// limit is the smaller of `leeway` and `repeating/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter deadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on Mach absolute |
| /// time. |
| /// - parameter repeating: the repeat interval for the timer in seconds, or `.infinity` if the timer |
| /// should fire only once. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, introduced: 4) |
| public func schedule(deadline: DispatchTime, repeating interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, interval.isInfinite ? ~0 : UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, repeat interval and leeway for a timer event. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `wallDeadline` and every `repeating` units of |
| /// time thereafter until the timer source is canceled. If the value of `repeating` is `.never`, |
| /// or is defaulted, the timer fires only once. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption and |
| /// system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `wallDeadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `wallDeadline + N * repeating`, the upper |
| /// limit is the smaller of `leeway` and `repeating/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter wallDeadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on |
| /// `gettimeofday(3)`. |
| /// - parameter repeating: the repeat interval for the timer, or `.never` if the timer should fire |
| /// only once. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, introduced: 4) |
| public func schedule(wallDeadline: DispatchWallTime, repeating interval: DispatchTimeInterval = .never, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval == .never ? ~0 : UInt64(interval.rawValue), UInt64(leeway.rawValue)) |
| } |
| |
| /// |
| /// Sets the deadline, repeat interval and leeway for a timer event that fires at least once. |
| /// |
| /// Once this function returns, any pending source data accumulated for the previous timer values |
| /// has been cleared. The next timer event will occur at `wallDeadline` and every `repeating` seconds |
| /// thereafter until the timer source is canceled. If the value of `repeating` is `.infinity`, |
| /// the timer fires only once. |
| /// |
| /// Delivery of a timer event may be delayed by the system in order to improve power consumption |
| /// and system performance. The upper limit to the allowable delay may be configured with the `leeway` |
| /// argument; the lower limit is under the control of the system. |
| /// |
| /// For the initial timer fire at `wallDeadline`, the upper limit to the allowable delay is set to |
| /// `leeway`. For the subsequent timer fires at `wallDeadline + N * repeating`, the upper |
| /// limit is the smaller of `leeway` and `repeating/2`. |
| /// |
| /// The lower limit to the allowable delay may vary with process state such as visibility of the |
| /// application UI. If the timer source was created with flags `TimerFlags.strict`, the system |
| /// will make a best effort to strictly observe the provided `leeway` value, even if it is smaller |
| /// than the current lower limit. Note that a minimal amount of delay is to be expected even if |
| /// this flag is specified. |
| /// |
| /// Calling this method has no effect if the timer source has already been canceled. |
| /// |
| /// - parameter wallDeadline: the time at which the timer event will be delivered, subject to the |
| /// leeway and other considerations described above. The deadline is based on |
| /// `gettimeofday(3)`. |
| /// - parameter repeating: the repeat interval for the timer in seconds, or `.infinity` if the timer |
| /// should fire only once. |
| /// - parameter leeway: the leeway for the timer. |
| /// |
| @available(swift, introduced: 4) |
| public func schedule(wallDeadline: DispatchWallTime, repeating interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) { |
| dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval.isInfinite ? ~0 : UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue)) |
| } |
| } |
| |
| #if !os(Linux) && !os(Android) |
| public extension DispatchSourceFileSystemObject { |
| public var handle: Int32 { |
| return Int32(dispatch_source_get_handle((self as! DispatchSource).__wrapped)) |
| } |
| |
| public var data: DispatchSource.FileSystemEvent { |
| let data = dispatch_source_get_data((self as! DispatchSource).__wrapped) |
| return DispatchSource.FileSystemEvent(rawValue: data) |
| } |
| |
| public var mask: DispatchSource.FileSystemEvent { |
| let data = dispatch_source_get_mask((self as! DispatchSource).__wrapped) |
| return DispatchSource.FileSystemEvent(rawValue: data) |
| } |
| } |
| #endif |
| |
| public extension DispatchSourceUserDataAdd { |
| /// Merges data into a dispatch source of type `DISPATCH_SOURCE_TYPE_DATA_ADD` |
| /// and submits its event handler block to its target queue. |
| /// |
| /// - parameter data: the value to add to the current pending data. A value of zero |
| /// has no effect and will not result in the submission of the event handler block. |
| public func add(data: UInt) { |
| dispatch_source_merge_data((self as! DispatchSource).__wrapped, data) |
| } |
| } |
| |
| public extension DispatchSourceUserDataOr { |
| /// Merges data into a dispatch source of type `DISPATCH_SOURCE_TYPE_DATA_OR` and |
| /// submits its event handler block to its target queue. |
| /// |
| /// - parameter data: The value to OR into the current pending data. A value of zero |
| /// has no effect and will not result in the submission of the event handler block. |
| public func or(data: UInt) { |
| dispatch_source_merge_data((self as! DispatchSource).__wrapped, data) |
| } |
| } |
| |
| public extension DispatchSourceUserDataReplace { |
| /// Merges data into a dispatch source of type `DISPATCH_SOURCE_TYPE_DATA_REPLACE` |
| /// and submits its event handler block to its target queue. |
| /// |
| /// - parameter data: The value that will replace the current pending data. |
| /// A value of zero will be stored but will not result in the submission of the event |
| /// handler block. |
| public func replace(data: UInt) { |
| dispatch_source_merge_data((self as! DispatchSource).__wrapped, data) |
| } |
| } |
| |
| @_silgen_name("_swift_dispatch_source_type_DATA_ADD") |
| internal func _swift_dispatch_source_type_data_add() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_DATA_OR") |
| internal func _swift_dispatch_source_type_data_or() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_DATA_REPLACE") |
| internal func _swift_dispatch_source_type_data_replace() -> dispatch_source_type_t |
| |
| #if HAVE_MACH |
| @_silgen_name("_swift_dispatch_source_type_MACH_SEND") |
| internal func _swift_dispatch_source_type_mach_send() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_MACH_RECV") |
| internal func _swift_dispatch_source_type_mach_recv() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_MEMORYPRESSURE") |
| internal func _swift_dispatch_source_type_memorypressure() -> dispatch_source_type_t |
| #endif |
| |
| #if !os(Linux) && !os(Android) |
| @_silgen_name("_swift_dispatch_source_type_PROC") |
| internal func _swift_dispatch_source_type_proc() -> dispatch_source_type_t |
| #endif |
| |
| @_silgen_name("_swift_dispatch_source_type_READ") |
| internal func _swift_dispatch_source_type_read() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_SIGNAL") |
| internal func _swift_dispatch_source_type_signal() -> dispatch_source_type_t |
| |
| @_silgen_name("_swift_dispatch_source_type_TIMER") |
| internal func _swift_dispatch_source_type_timer() -> dispatch_source_type_t |
| |
| #if !os(Linux) && !os(Android) |
| @_silgen_name("_swift_dispatch_source_type_VNODE") |
| internal func _swift_dispatch_source_type_vnode() -> dispatch_source_type_t |
| #endif |
| |
| @_silgen_name("_swift_dispatch_source_type_WRITE") |
| internal func _swift_dispatch_source_type_write() -> dispatch_source_type_t |