Up
Authors
- Gregory Casamento (
greg.casamento@gmail.com
)
-
- Richard Frith-Macdonald (
rfm@gnu.org
)
-
Version: 26606
Date: 2008-06-08 11:38:33 +0100 (Sun, 08 Jun 2008)
Copyright: (C) 2009,2010 Free Software Foundation, Inc.
- Declared in:
- Foundation/NSOperation.h
Availability: OpenStep
Description forthcoming.
Method summary
+ (instancetype)
blockOperationWithBlock: (GSBlockOperationBlock)block;
Availability: OpenStep
Description forthcoming.
- (void)
addExecutionBlock: (GSBlockOperationBlock)block;
Availability: OpenStep
Description forthcoming.
- (
NSArray*)
executionBlocks;
Availability: OpenStep
Description forthcoming.
- Declared in:
- Foundation/NSOperation.h
Availability: MacOS-X 10.5.0
Description forthcoming.
Method summary
- (void)
addDependency: (
NSOperation*)op;
Availability: OpenStep
Adds a dependency to the receiver.
The receiver
is not considered ready to execute until all of its
dependencies have finished executing.
You must not add a particular object to the receiver
more than once.
You must not create loops of
dependencies (this would cause deadlock).
- (void)
cancel;
Availability: OpenStep
Marks the operation as cancelled (causes subsequent
calls to the
-isCancelled
method to return
YES
).
This does
not directly cause the receiver to stop executing... it
is the responsibility of the receiver to call
-isCancelled
while executing and act accordingly.
If an
operation in a queue is cancelled before it
starts executing, it will be removed from the queue
(though not necessarily immediately).
Calling this method on an object which has already
finished executing has no effect.
- (GSOperationCompletionBlock)
completionBlock;
Availability: MacOS-X 10.6.0
Returns the block that will be executed after the
operation finishes.
- (
NSArray*)
dependencies;
Availability: OpenStep
Returns all the dependencies of the receiver in the
order in which they were added.
- (BOOL)
isCancelled;
Availability: OpenStep
This method should return
YES
if the
-cancel
method has been called.
NB. a cancelled
operation may still be executing.
- (BOOL)
isConcurrent;
Availability: OpenStep
This method returns
YES
if the receiver
handles its own environment or threading rather
than expecting to run in an evironment set up
elsewhere (eg, by an
NSOperationQueue
instance).
The default implementation
returns
NO
.
- (BOOL)
isExecuting;
Availability: OpenStep
This method should return
YES
if the
receiver is currently executing its
-main
method (even if
-cancel
has been called).
- (BOOL)
isFinished;
Availability: OpenStep
This method should return
YES
if the
receiver has finished executing its
-main
method (irrespective of whether the execution
completed due to cancellation, failure, or
success).
- (BOOL)
isReady;
Availability: OpenStep
This method should return YES
when the
receiver is ready to begin executing. That is, the
receiver must have no dependencies which have not
finished executing.
Also returns
YES
if the operation has been cancelled
(even if there are unfinished dependencies).
An executing or finished operation is also considered to
be ready.
- (void)
main;
Availability: OpenStep
Subclasses
must override this method.
This is the method which actually performs the
operation... the default implementation does
nothing.
You MUST ensure that your
implemention of
-main
does not raise any exception or call
[NSThread -exit]
as either of these will terminate the operation
prematurely resulting in the operation never
reaching the
-isFinished
state.
If you are writing a concurrent
subclass, you should override
-start
instead of (or as well as) the
-main
method.
- (
NSOperationQueuePriority)
queuePriority;
Availability: OpenStep
Returns the priority set using the
-setQueuePriority
method, or NSOperationQueuePriorityNormal if no
priority has been set.
- (void)
removeDependency: (
NSOperation*)op;
Availability: OpenStep
Removes a dependency from the receiver.
- (void)
setCompletionBlock: (GSOperationCompletionBlock)aBlock;
Availability: MacOS-X 10.6.0
Sets the block that will be executed when the
operation has finished.
- (void)
setQueuePriority: (
NSOperationQueuePriority)pri;
Availability: OpenStep
Sets the priority for the receiver. If the value
supplied is not one of the predefined queue
priorities, it is converted into the next
available defined value moving towards
NSOperationQueuePriorityNormal.
- (void)
setThreadPriority: (double)pri;
Availability: MacOS-X 10.6.0
Sets the thread priority to be used while executing
then
-main
method.
The priority change is implemented in the
-start
method, so if you are replacing
-start
you are responsible for managing this.
The valid
range is 0.0 to 1.0
- (void)
start;
Availability: OpenStep
This method is called to start execution of the
receiver.
For concurrent operations, the subclass must override
this method to set up the environment for the
operation to execute, must execute the
-main
method, must ensure that
-isExecuting
and
-isFinished
return the correct values, and must manually call
key-value-observing methods to notify
observers of the state of those two properties.
The subclass implementation must NOT call
the superclass implementation.
For non-concurrent operations, the default
implementation of this method performs all
the work of setting up environment etc, and the
subclass only needs to override the
-main
method.
- (double)
threadPriority;
Availability: MacOS-X 10.6.0
Returns the thread priority to be used executing
the
-main
method.
The default is 0.5
- (void)
waitUntilFinished;
Availability: MacOS-X 10.6.0
This method blocks the current thread until the
receiver finishes.
Care must be taken to
avoid deadlock... you must not call this method from
the same thread that the receiver started in.
- Declared in:
- Foundation/NSOperation.h
Availability: OpenStep
Description forthcoming.
Method summary
+ (id)
currentQueue;
Availability: MacOS-X 10.6.0
If called from within the
-main
method of an operation which is currently being
executed by a queue, this returns the queue
instance in use.
+ (id)
mainQueue;
Availability: MacOS-X 10.6.0
Returns the default queue on the main thread.
- (void)
addOperation: (
NSOperation*)op;
Availability: OpenStep
Adds an operation to the receiver.
- (void)
addOperationWithBlock: (GSBlockOperationBlock)block;
Availability: MacOS-X 10.6.0
This method wraps a block in an operation
and adds it to the queue.
- (void)
addOperations: (
NSArray*)ops
waitUntilFinished: (BOOL)shouldWait;
Availability: MacOS-X 10.6.0
Adds multiple operations to the receiver and
(optionally) waits for all the operations in
the queue to finish.
- (void)
cancelAllOperations;
Availability: OpenStep
Cancels all outstanding operations in the queue.
- (BOOL)
isSuspended;
Availability: OpenStep
Returns a flag indicating whether the queue is
currently suspended.
- (
NSInteger)
maxConcurrentOperationCount;
Availability: OpenStep
- (
NSString*)
name;
Availability: MacOS-X 10.6.0
Return the name of this operation queue.
- (
NSUInteger)
operationCount;
Availability: MacOS-X 10.6.0
Return the number of operations in the queue at an
instant.
- (
NSArray*)
operations;
Availability: OpenStep
Returns all the operations in the queue at an
instant.
- (void)
setMaxConcurrentOperationCount: (
NSInteger)cnt;
Availability: OpenStep
Sets the number of concurrent operations permitted.
The default
(NSOperationQueueDefaultMaxConcurrentOperationCount)
means that the queue should decide how many it does
based on system load etc.
- (void)
setName: (
NSString*)s;
Availability: MacOS-X 10.6.0
Sets the name for this operation queue.
- (void)
setSuspended: (BOOL)flag;
Availability: OpenStep
Marks the receiver as suspended... while suspended an
operation queue will not start any more
operations.
- (void)
waitUntilAllOperationsAreFinished;
Availability: OpenStep
Waits until all operations in the queue have finished
(or been cancelled and removed from the queue).
Up