import Dispatch3

class DispatchStuff
{
    let sq = DispatchQueue("com.example.some_queue", attr: .serial)
    let cq = DispatchQueue("com.example.another_queue", attr: .concurrent)

    let x = 5

    func foo() throws
    {
        // You can return from a sync closure! And you don't have to
        // reference self (closure is @noescape)

        let y = sq.sync { return x }

        // You can also throw from a sync closure!
        try sq.sync { throw SomeException }

        // dispatch_after is much simpler
        sq.after(.now() + 5) { print "Isn't that much easier?" }
        sq.after(.now() + .milliseconds(500)) { print "No conversions necessary" }

        // Dispatch groups!
        let g = DispatchGroup()
        cq.async(group: g) { /* Do the thing */ }
        cq.async(group: g) { /* Do the other thing */ }
        g.enter()
        someObject.customThing(completion: { g.leave() })
        group.notify { /* Do when thing, other thing, and custom thing are done */ }

        // Barrier blocks!
        for i in 0..<10
        {
            cq.async { /* Do the thing */ }
        }

        cq.async(flags: .barrier) { /* called after cq is drained */ }

        // Dispatch on the main queue
        DispatchQueue.main.async { /* update the UI */ }

        // Dispatch on a global queue
        DispatchQueue.global(attributes: .qosBackground).async { ... }
    }

    func bar()
    {
        // Preconditions!
        dispatchPrecondition(.onQueue(sq))
        dispatchPrecondition(.notOnQueue(cq))
        print("I feel safer already")
    }
}