libdispatch-913.30.4.tar.gz

[apple/libdispatch.git] / src / swift / Source.swift

diff --git a/src/swift/Source.swift b/src/swift/Source.swift
index 2830f010efabfc22bd1b018d043ed0b2496a0a19..421a6e9bb65415f0a13964284979a1a9710bb2c9 100644 (file)
--- a/src/swift/Source.swift
+++ b/src/swift/Source.swift
@@ -12,10 +12,10 @@
 
 import CDispatch
 
 
 import CDispatch
 

-public extension DispatchSourceType {
+public extension DispatchSourceProtocol {

 
        public func setEventHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {
 
        public func setEventHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {

-               if #available(OSX 10.10, iOS 8.0, *), let h = handler where qos != .unspecified || !flags.isEmpty {
+               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 {
                        let item = DispatchWorkItem(qos: qos, flags: flags, block: h)
                        CDispatch.dispatch_source_set_event_handler((self as! DispatchSource).__wrapped, item._block)
                } else {


@@ -29,7 +29,7 @@ public extension DispatchSourceType {
        }
 
        public func setCancelHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {
        }
 
        public func setCancelHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {

-               if #available(OSX 10.10, iOS 8.0, *), let h = handler where qos != .unspecified || !flags.isEmpty {
+               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 {
                        let item = DispatchWorkItem(qos: qos, flags: flags, block: h)
                        CDispatch.dispatch_source_set_cancel_handler((self as! DispatchSource).__wrapped, item._block)
                } else {


@@ -43,7 +43,7 @@ public extension DispatchSourceType {
        }
 
        public func setRegistrationHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {
        }
 
        public func setRegistrationHandler(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], handler: DispatchSourceHandler?) {

-               if #available(OSX 10.10, iOS 8.0, *), let h = handler where qos != .unspecified || !flags.isEmpty {
+               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 {
                        let item = DispatchWorkItem(qos: qos, flags: flags, block: h)
                        CDispatch.dispatch_source_set_registration_handler((self as! DispatchSource).__wrapped, item._block)
                } else {


@@ -112,7 +112,7 @@ public extension DispatchSource {
        }
 #endif
 
        }
 #endif
 

-#if !os(Linux)
+#if !os(Linux) && !os(Android)

        public struct ProcessEvent : OptionSet, RawRepresentable {
                public let rawValue: UInt
                public init(rawValue: UInt) { self.rawValue = rawValue }
        public struct ProcessEvent : OptionSet, RawRepresentable {
                public let rawValue: UInt
                public init(rawValue: UInt) { self.rawValue = rawValue }


@@ -150,66 +150,71 @@ public extension DispatchSource {
        }
 
 #if HAVE_MACH
        }
 
 #if HAVE_MACH

-       public class func machSend(port: mach_port_t, eventMask: MachSendEvent, queue: DispatchQueue? = nil) -> DispatchSourceMachSend {
+       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
                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 machReceive(port: mach_port_t, queue: DispatchQueue? = nil) -> DispatchSourceMachReceive {
+       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
                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 memoryPressure(eventMask: MemoryPressureEvent, queue: DispatchQueue? = nil) -> DispatchSourceMemoryPressure {
+       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
 
                let source = dispatch_source_create(_swift_dispatch_source_type_memorypressure(), 0, eventMask.rawValue, queue.__wrapped)
                return DispatchSourceMemoryPressure(source)
        }
 #endif
 

-#if !os(Linux)
-       public class func process(identifier: pid_t, eventMask: ProcessEvent, queue: DispatchQueue? = nil) -> DispatchSourceProcess {
+#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
 
                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 read(fileDescriptor: Int32, queue: DispatchQueue? = nil) -> DispatchSourceRead {
+       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
        }
 
                let source = dispatch_source_create(_swift_dispatch_source_type_read(), UInt(fileDescriptor), 0, queue?.__wrapped)
                return DispatchSource(source: source) as DispatchSourceRead
        }
 

-       public class func signal(signal: Int32, queue: DispatchQueue? = nil) -> DispatchSourceSignal {
+       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
        }
 
                let source = dispatch_source_create(_swift_dispatch_source_type_signal(), UInt(signal), 0, queue?.__wrapped)
                return DispatchSource(source: source) as DispatchSourceSignal
        }
 

-       public class func timer(flags: TimerFlags = [], queue: DispatchQueue? = nil) -> DispatchSourceTimer {
+       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
        }
 
                let source = dispatch_source_create(_swift_dispatch_source_type_timer(), 0, flags.rawValue, queue?.__wrapped)
                return DispatchSource(source: source) as DispatchSourceTimer
        }
 

-       public class func userDataAdd(queue: DispatchQueue? = nil) -> DispatchSourceUserDataAdd {
+       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
        }
 
                let source = dispatch_source_create(_swift_dispatch_source_type_data_add(), 0, 0, queue?.__wrapped)
                return DispatchSource(source: source) as DispatchSourceUserDataAdd
        }
 

-       public class func userDataOr(queue: DispatchQueue? = nil) -> DispatchSourceUserDataOr {
+       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
        }
                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)
-       public class func fileSystemObject(fileDescriptor: Int32, eventMask: FileSystemEvent, queue: DispatchQueue? = nil) -> DispatchSourceFileSystemObject {
+#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
 
                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 write(fileDescriptor: Int32, queue: DispatchQueue? = nil) -> DispatchSourceWrite {
+       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
        }
                let source = dispatch_source_create(_swift_dispatch_source_type_write(), UInt(fileDescriptor), 0, queue?.__wrapped)
                return DispatchSource(source: source) as DispatchSourceWrite
        }


@@ -255,7 +260,7 @@ public extension DispatchSourceMemoryPressure {
 }
 #endif
 
 }
 #endif
 

-#if !os(Linux)
+#if !os(Linux) && !os(Android)

 public extension DispatchSourceProcess {
        public var handle: pid_t {
                return pid_t(dispatch_source_get_handle(self as! DispatchSource))
 public extension DispatchSourceProcess {
        public var handle: pid_t {
                return pid_t(dispatch_source_get_handle(self as! DispatchSource))


@@ -274,64 +279,346 @@ public extension DispatchSourceProcess {
 #endif
 
 public extension DispatchSourceTimer {
 #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))
        }
 
        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))
        }
 
        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)) {
        public func scheduleRepeating(deadline: DispatchTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) {

-               dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, interval.rawValue, UInt64(leeway.rawValue))
+               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)) {
        public func scheduleRepeating(deadline: DispatchTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {

-               dispatch_source_set_timer((self as! DispatchSource).__wrapped, deadline.rawValue, UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue))
+               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)) {
        public func scheduleRepeating(wallDeadline: DispatchWallTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) {

-               dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval.rawValue, UInt64(leeway.rawValue))
+               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)) {
        public func scheduleRepeating(wallDeadline: DispatchWallTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {

-               dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue))
-       }
-}
-
-public extension DispatchSourceTimer {
-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleOneshot(self:deadline:leeway:)")
-       public func setTimer(start: DispatchTime, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleOneshot(deadline: start, leeway: leeway)
-       }
-
-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleOneshot(self:wallDeadline:leeway:)")
-       public func setTimer(walltime start: DispatchWallTime, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleOneshot(wallDeadline: start, leeway: leeway)
+               dispatch_source_set_timer((self as! DispatchSource).__wrapped, wallDeadline.rawValue, interval.isInfinite ? ~0 : UInt64(interval * Double(NSEC_PER_SEC)), UInt64(leeway.rawValue))

        }
 
        }
 

-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleRepeating(self:deadline:interval:leeway:)")
-       public func setTimer(start: DispatchTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleRepeating(deadline: start, interval: interval, leeway: leeway)
+       ///
+       /// 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))

        }
 
        }
 

-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleRepeating(self:deadline:interval:leeway:)")
-       public func setTimer(start: DispatchTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleRepeating(deadline: start, interval: interval, leeway: leeway)
+       ///
+       /// 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))

        }
 
        }
 

-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleRepeating(self:wallDeadline:interval:leeway:)")
-       public func setTimer(walltime start: DispatchWallTime, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleRepeating(wallDeadline: start, interval: interval, leeway: leeway)
+       ///
+       /// 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))

        }
 
        }
 

-       @available(*, deprecated, renamed: "DispatchSourceTimer.scheduleRepeating(self:wallDeadline:interval:leeway:)")
-       public func setTimer(walltime start: DispatchWallTime, interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {
-               scheduleRepeating(wallDeadline: start, interval: interval, leeway: leeway)
+       ///
+       /// 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)
+#if !os(Linux) && !os(Android)

 public extension DispatchSourceFileSystemObject {
        public var handle: Int32 {
                return Int32(dispatch_source_get_handle((self as! DispatchSource).__wrapped))
 public extension DispatchSourceFileSystemObject {
        public var handle: Int32 {
                return Int32(dispatch_source_get_handle((self as! DispatchSource).__wrapped))


@@ -350,39 +637,37 @@ public extension DispatchSourceFileSystemObject {
 #endif
 
 public extension DispatchSourceUserDataAdd {
 #endif
 
 public extension DispatchSourceUserDataAdd {

-       /// @function mergeData
-       ///
-       /// @abstract
-       /// Merges data into a dispatch source of type DISPATCH_SOURCE_TYPE_DATA_ADD or
-       /// DISPATCH_SOURCE_TYPE_DATA_OR and submits its event handler block to its
-       /// target queue.
+       /// Merges data into a dispatch source of type `DISPATCH_SOURCE_TYPE_DATA_ADD`
+       /// and submits its event handler block to its target queue.

        ///
        ///

-       /// @param value
-       /// The value to coalesce with the pending data using a logical OR or an ADD
-       /// as specified by the dispatch source type. A value of zero has no effect
-       /// and will not result in the submission of the event handler block.
-       public func mergeData(value: UInt) {
-               dispatch_source_merge_data((self as! DispatchSource).__wrapped, value)
+       /// - 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 {
        }
 }
 
 public extension DispatchSourceUserDataOr {

-#if false /*FIXME: clashes with UserDataAdd?? */
-       /// @function mergeData
+       /// Merges data into a dispatch source of type `DISPATCH_SOURCE_TYPE_DATA_OR` and
+       /// submits its event handler block to its target queue.

        ///
        ///

-       /// @abstract
-       /// Merges data into a dispatch source of type DISPATCH_SOURCE_TYPE_DATA_ADD or
-       /// 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.

        ///
        ///

-       /// @param value
-       /// The value to coalesce with the pending data using a logical OR or an ADD
-       /// as specified by the dispatch source type. A value of zero has no effect
-       /// and will not result in the submission of the event handler block.
-       public func mergeData(value: UInt) {
-               dispatch_source_merge_data((self as! DispatchSource).__wrapped, value)
+       /// - 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)

        }
        }

-#endif

 }
 
 @_silgen_name("_swift_dispatch_source_type_DATA_ADD")
 }
 
 @_silgen_name("_swift_dispatch_source_type_DATA_ADD")


@@ -391,6 +676,9 @@ 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_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
 #if HAVE_MACH
 @_silgen_name("_swift_dispatch_source_type_MACH_SEND")
 internal func _swift_dispatch_source_type_mach_send() -> dispatch_source_type_t


@@ -402,7 +690,7 @@ internal func _swift_dispatch_source_type_mach_recv() -> dispatch_source_type_t
 internal func _swift_dispatch_source_type_memorypressure() -> dispatch_source_type_t
 #endif
 
 internal func _swift_dispatch_source_type_memorypressure() -> dispatch_source_type_t
 #endif
 

-#if !os(Linux)
+#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_PROC")
 internal func _swift_dispatch_source_type_proc() -> dispatch_source_type_t
 #endif


@@ -416,7 +704,7 @@ 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
 
 @_silgen_name("_swift_dispatch_source_type_TIMER")
 internal func _swift_dispatch_source_type_timer() -> dispatch_source_type_t
 

-#if !os(Linux)
+#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_VNODE")
 internal func _swift_dispatch_source_type_vnode() -> dispatch_source_type_t
 #endif