IntervalFlags

import Dispatch

class DispatchIO

convenience init(type: DispatchIO.StreamType, fileDescriptor: dispatch_fd_t, queue: DispatchQueue, cleanupHandler: @escaping (Int32) -> Void)

convenience init(type: DispatchIO.StreamType, io: DispatchIO, queue: DispatchQueue, cleanupHandler: @escaping (Int32) -> Void)

convenience init?(type: DispatchIO.StreamType, path: UnsafePointer<Int8>, oflag: Int32, mode: mode_t, queue: DispatchQueue, cleanupHandler: @escaping (Int32) -> Void)

class func read(fromFileDescriptor: Int32, maxLength: Int, runningHandlerOn queue: DispatchQueue, handler: @escaping (DispatchData, Int32) -> Void)

class func write(toFileDescriptor: Int32, data: DispatchData, runningHandlerOn queue: DispatchQueue, handler: @escaping (DispatchData?, Int32) -> Void)

var fileDescriptor: Int32 { get }

func barrier(execute: @escaping () -> ())

func close(flags: DispatchIO.CloseFlags = [])

func read(offset: off_t, length: Int, queue: DispatchQueue, ioHandler: @escaping (Bool, DispatchData?, Int32) -> Void)

func setInterval(interval: DispatchTimeInterval, flags: DispatchIO.IntervalFlags = [])

func setLimit(highWater: Int)

func setLimit(lowWater: Int)

func write(offset: off_t, data: DispatchData, queue: DispatchQueue, ioHandler: @escaping (Bool, DispatchData?, Int32) -> Void)

struct CloseFlags

enum StreamType

convenience init(type: DispatchIO.StreamType, path: UnsafePointer<Int8>, oflag: Int32, mode: mode_t, queue: DispatchQueue, cleanupHandler: @escaping (Int32) -> Void)

protocol Equatable

A type that can be compared for value equality.

protocol ExpressibleByArrayLiteral

A type that can be initialized using an array literal.

protocol OptionSet : RawRepresentable, SetAlgebra

A type that presents a mathematical set interface to a bit set.

protocol RawRepresentable<RawValue>

A type that can be converted to and from an associated raw value.

protocol SetAlgebra<Element> : Equatable, ExpressibleByArrayLiteral

A type that provides mathematical set operations.

init(nilLiteral: ())

init(rawValue: UInt)

static let strictInterval: DispatchIO.IntervalFlags

let rawValue: UInt

init()

Creates an empty option set.

init<S>(_ sequence: S) where S : Sequence, Self.Element == S.Element

Creates a new set from a finite sequence of items.

init(arrayLiteral: Self.Element...)

Creates a set containing the elements of the given array literal.

var isEmpty: Bool { get }

A Boolean value that indicates whether the set has no elements.

static func != (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether two values are not equal.

func contains(_ member: Self) -> Bool

Returns a Boolean value that indicates whether a given element is a member of the option set.

mutating func formIntersection(_ other: Self)

Removes all elements of this option set that are not also present in the given set.

mutating func formSymmetricDifference(_ other: Self)

Replaces this set with a new set containing all elements contained in either this set or the given set, but not in both.

mutating func formUnion(_ other: Self)

Inserts the elements of another set into this option set.

@discardableResult mutating func insert(_ newMember: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element)

Adds the given element to the option set if it is not already a member.

func intersection(_ other: Self) -> Self

Returns a new option set with only the elements contained in both this set and the given set.

func isDisjoint(with other: Self) -> Bool

Returns a Boolean value that indicates whether the set has no members in common with the given set.

func isStrictSubset(of other: Self) -> Bool

Returns a Boolean value that indicates whether this set is a strict subset of the given set.

func isStrictSuperset(of other: Self) -> Bool

Returns a Boolean value that indicates whether this set is a strict superset of the given set.

func isSubset(of other: Self) -> Bool

Returns a Boolean value that indicates whether the set is a subset of another set.

func isSuperset(of other: Self) -> Bool

Returns a Boolean value that indicates whether the set is a superset of the given set.

@discardableResult mutating func remove(_ member: Self.Element) -> Self.Element?

Removes the given element and all elements subsumed by it.

mutating func subtract(_ other: Self)

Removes the elements of the given set from this set.

func subtracting(_ other: Self) -> Self

Returns a new set containing the elements of this set that do not occur in the given set.

func symmetricDifference(_ other: Self) -> Self

Returns a new option set with the elements contained in this set or in the given set, but not in both.

func union(_ other: Self) -> Self

Returns a new option set of the elements contained in this set, in the given set, or in both.

@discardableResult mutating func update(with newMember: Self.Element) -> Self.Element?

Inserts the given element into the set.