SprintSwift 0.1.1

You want to add pod 'SprintSwift', '~> 0.1' similar to the following to your Podfile:

target 'MyApp' do
  pod 'SprintSwift', '~> 0.1'
end

Then run a pod install inside your terminal, or from CocoaPods.app.

Alternatively to give it a test run, run the command:

pod try SprintSwift

SprintSwift 0.1.1

By
Josh Wright

Sprint

Swift Grand Central Dispatch made easier

Overview

Sprint contains 3 types

Sprint: a dispatch_block_t wrapper
SprintQueue: a dispatch_queue_t wrapper
SprintGroup: a dispatch_group_t wrapper

Installation

Usage

Queue Basics

SprintQueue is an enum whose value is related to the Quality of Service Class (QoS) it is running on:

Main
UserInteractive
UserInitiated
Utility
Background

You can also have a custom queue, either serial or concurent

Custom(dispatch_queue_t)

Running on a Queue

let backgroundQueue: SprintQueue = .Background
backgroundQueue.async {
    // background work
}.finished {
    // background work is finished
    // this block will be run on the same thread as async
}.finished(.Main) {
    // this finish block will be run on the Main thread
    // finish can be chained as many times as you want
}

There is also a sync method that runs synchronously.

Running after a delay

SprintQueue has an after method to run a block after a set amount of seconds

let queue: SprintQueue = .Main
queue.after(5.0) {
    print("test")
}

// test will print after 5 seconds

Parallelizing Loops

Loops can be parallelized using the apply method

let dataToCompute: [SomeObject] = dataArray
var computedData = []

let queue: SprintQueue = .UserInitiated
queue.apply(dataToCompute.count) {
    index in
        let computedDatum = dataToCompute[index].computeData()
        computedData.apped(computedDatum)
}

Cancelling blocks

Each method returns a Sprint which can then be cancelled (assuming it hasn't begun)

let sprint = SprintQueue.Background.async {
    // update cache
}

// the operation is cancelled, if it has not been started   
sprint.cancel()

Custom Queues

Serial and Concurrent Queues

Besides the five built in QoS classes that Apple gives us, you can also create a custom Queue, either serial or concurrent, via two static methods:

// a custom concurrent queue
let concurrentQueue = SprintQueue.customConcurrent(label: "com.example.concurrent")

// A custom serial queue
let serialQueue = SprintQueue.customSerial(label: "com.example.concurrent")

Barrier operations

Barrier operations are written just like async and sync

let customConcurrentQueue = SprintQueue.customConcurrent(label: "com.example.barrierExample")

customConcurrentQueue.async {
    // stuff A
}

customConcurrentQueue.barrierAsync {
    // stuff B 
    // (something that could result in a race if not ran in a barrier)
}

customConcurrentQueue.async {
    // stuff C
}

// stuff B is guarenteed to happen after A is completed finished and stuff C will not happen until B is completely finished

Groups

You can also create dispatch groups for managing multiple asynchronous operations.

Running asynchronous operations on a group

Each SprintGroup has a built in async method that handles the entering and leaving of the group for that operation

let group = SprintGroup()
group.async(.Background) {
    // stuff 1
}

group.async(.UserInteractive) {
    // stuff 2
}

group.finished {
    // stuff 1 + 2 have finished running
    // functions exactly the same as Sprint.finished() with an optional SprintQueue parameter
}

Wait

groups also have a wait method

group.async {
    // stuff
}

group.async {
    // more stuff
}

if group.wait(10.0) {
    // the stuff finished in 10.0 seconds
} else {
    // the stuff did NOT finish in 10.0 seconds and the wait timed out
}

Entering and Leaving

you can also manually enter and leave if you want to manually manage an associated block for your SprintGroup

group.enter()

youownapi.call {
    // stuff
    other.call {
        // more stuff
        callback.hell {
            // even more stuff
            group.leave()   
        }
    }
}

group.wait(10.0)

// won't be executed until callback.hell is run or 10.0 seconds pass
print("done waiting")

Other

Thanks for checking this out :)

License

MIT

Contributing

Please do so! I'd love to hear your thoughts and opinions.