OperationPlus

Integration

dependencies:[.package(url:"https://github.com/ChimeHQ/OperationPlus.git")]

NSOperation Subclasses

leta=BaseOperation(timeout:5.0)// NSOperation will happily allow you do this even// if `a` has finished. `BaseOperation` will not.a.addDependency(another)// ...publicoverridefunc main(){    // This will return true if your operation is cancelled, timed out,    // or prematurely finished. ProducerOperation subclass state will be    // handled correctly as well.ifself.checkForCancellation(){return}}// ...

import Foundationimport OperationPlusclassMyAsyncOperation:AsyncOperation{publicoverridefunc main(){DispatchQueue.global().async{ifself.checkForCancellation(){return}            // do stuffself.finish()}}}

import Foundationimport OperationPlusclassMyAsyncOperation:BaseOperation{overrideopenvarisAsynchronous:Bool{returntrue}}

import Foundationimport OperationPlusclassMyValueOperation:ProducerOperation<Int>{publicoverridefunc main(){        // do your computationself.finish(with:42)}}// ...letop=MyValueOperation()op.resultCompletionBlock={(value)in    // use value here}

import Foundationimport OperationPlusclassMyAsyncOperation:AsyncProducerOperation<Int>{publicoverridefunc main(){DispatchQueue.global().async{ifself.checkForCancellation(){return}            // do stuffself.finish(with:42)}}}

import Foundationimport OperationPlusclassMyConsumerOperation:ConsumerOperation<Int>{overridefunc main(){guardlet value= producerValueelse{            // handle failure in some way}}overridefunc main(with value:Int){        // make use of value here, or automatically        // fail if it wasn't successfully produced}}letop=MyConsumerOperation(producerOp: myIntProducerOperation)

letop=AsyncBlockOperation{(completionBlock)inDispatchQueue.global().async{        // do some async work here, just be certain to call        // the completionBlock when donecompletionBlock()}}

NSOperation/NSOperationQueue Extensions

leta=OperationQueue(name:"myqueue")letb=OperationQueue(name:"myqueue", maxConcurrentOperations:1)letc=OperationQueue.serialQueue()letd=OperationQueue.serialQueue(named:"myqueue")

OperationQueue.preconditionMain()OperationQueue.preconditionNotMain()

queue.addOperation(op, dependency: opA)queue.addOperation(op, dependencies:[opA, opB])queue.addOperation(op, dependencies:Set([opA, opB]))op.addDependencies([opA, opB])op.addDependencies(Set([opA, opB]))

queue.currentOperationsFinished{print("all pending ops done")}

queue.addAsyncOperation{(completionHandler)inDispatchQueue.global().async{        // do some async workcompletionHandler()}}

queue.addOperation{awaitasyncFunction1()awaitasyncFunction2()}letvalue=tryawait queue.addResultOperation{tryawaitasyncValue()}

queue.addOperation(op, afterDelay:5.0)queue.addOperation(afterDelay:5.0){  // work}

Combine Integration

op.publisher() // AnyPublisher<Void, Never>producerOp.outputPublisher() // AnyPublisher<Output, Never>

publisher.operation() // PublisherOperationpublisher.execute(on: queue) // subscribes and executes chain on queue and returns a publisher for result

XCTest Support

letop=NeverFinishingOperation()letexpectation=OperationExpectation(operation: op)expectation.isInverted=truewait(for:[expectation], timeout:1.0)

Suggestions or Feedback