CPOperation.j

Go to the documentation of this file.

/*
 * CPOperation.j
 *
 * Created by Johannes Fahrenkrug.
 * Copyright 2009, Springenwerk.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */


@global CPKeyValueObservingOptionNew

CPOperationQueuePriorityVeryLow     = -8;

CPOperationQueuePriorityLow         = -4;

CPOperationQueuePriorityNormal      = 0;

CPOperationQueuePriorityHigh        = 4;

CPOperationQueuePriorityVeryHigh    = 8;


@implementation CPOperation : CPObject
{
    CPArray operations;
    BOOL _cancelled;
    BOOL _executing;
    BOOL _finished;
    BOOL _ready;
    int _queuePriority;
    JSObject _completionFunction;
    CPArray _dependencies;
}

- (void)main
{
    // should be overridden in child class
}

- (id)init
{
    self = [super init];

    if (self)
    {
        _cancelled = NO;
        _executing = NO;
        _finished = NO;
        _ready = YES;
        _dependencies = [[CPArray alloc] init];
        _queuePriority = CPOperationQueuePriorityNormal;
    }
    return self;
}

- (void)start
{
    if (!_cancelled)
    {
        [self willChangeValueForKey:@"isExecuting"];
        _executing = YES;
        [self didChangeValueForKey:@"isExecuting"];
        [self main];
        if (_completionFunction)
        {
            _completionFunction();
        }
        [self willChangeValueForKey:@"isExecuting"];
        _executing = NO;
        [self didChangeValueForKey:@"isExecuting"];
    }

    [self willChangeValueForKey:@"isFinished"];
    _finished = YES;
    [self didChangeValueForKey:@"isFinished"];
}

- (BOOL)isCancelled
{
    return _cancelled;
}

- (BOOL)isExecuting
{
    return _executing;
}

- (BOOL)isFinished
{
    return _finished;
}

- (BOOL)isConcurrent
{
    return NO;
}

- (BOOL)isReady
{
    return _ready;
}

- (JSObject)completionFunction
{
    return _completionFunction;
}

- (void)setCompletionFunction:(JSObject)aJavaScriptFunction
{
    _completionFunction = aJavaScriptFunction;
}

- (void)addDependency:(CPOperation)anOperation
{
    [self willChangeValueForKey:@"dependencies"];
    [anOperation addObserver:self
                  forKeyPath:@"isFinished"
                     options:(CPKeyValueObservingOptionNew)
                     context:NULL];
    [_dependencies addObject:anOperation];
    [self didChangeValueForKey:@"dependencies"];
    [self _updateIsReadyState];
}

- (void)removeDependency:(CPOperation)anOperation
{
    [self willChangeValueForKey:@"dependencies"];
    [_dependencies removeObject:anOperation];
    [anOperation removeObserver:self
                     forKeyPath:@"isFinished"];
    [self didChangeValueForKey:@"dependencies"];
    [self _updateIsReadyState];
}

- (CPArray)dependencies
{
    return _dependencies;
}

- (void)waitUntilFinished
{
}

- (void)cancel
{
    [self willChangeValueForKey:@"isCancelled"];
    _cancelled = YES;
    [self didChangeValueForKey:@"isCancelled"];
}

- (void)setQueuePriority:(int)priority
{
    _queuePriority = priority;
}

- (int)queuePriority
{
    return _queuePriority;
}

// We need to observe the "isFinished" key of our dependent operations so we can update our own "isReady" state
- (void)observeValueForKeyPath:(CPString)keyPath
                      ofObject:(id)object
                        change:(CPDictionary)change
                       context:(void)context
{
    if (keyPath == @"isFinished")
    {
        [self _updateIsReadyState];
    }
}

- (void)_updateIsReadyState
{
    var newReady = YES;
    if (_dependencies && [_dependencies count] > 0)
    {
        var i = 0;
        for (i = 0; i < [_dependencies count]; i++)
        {
            if (![[_dependencies objectAtIndex:i] isFinished])
            {
                newReady = NO;
            }
        }
    }

    if (newReady != _ready)
    {
        [self willChangeValueForKey:@"isReady"];
        _ready = newReady;
        [self didChangeValueForKey:@"isReady"];
    }
}

@end