CPOperationQueue.j

Go to the documentation of this file.

/*
 * CPOperationQueue.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
 */


// the global queue (mainQueue)
var cpOperationMainQueue = nil;

@implementation CPOperationQueue : CPObject
{
    CPArray _operations;
    BOOL _suspended;
    CPString _name;
    CPTimer _timer;
}

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

    if (self)
    {
        _operations = [[CPArray alloc] init];
        _suspended = NO;
//        _currentlyModifyingOps = NO;
        _timer = [CPTimer scheduledTimerWithTimeInterval:0.01
                                                  target:self
                                                selector:@selector(_runNextOpsInQueue)
                                                userInfo:nil
                                                 repeats:YES];
    }
    return self;
}

- (void)_runNextOpsInQueue
{
    if (!_suspended && [self operationCount] > 0)
    {
        var i = 0,
            count = [_operations count];

        for (; i < count; i++)
        {
            var op = [_operations objectAtIndex:i];
            if ([op isReady] && ![op isFinished] && ![op isExecuting])
            {
                [op start];
            }
        }
    }
}

- (void)_enableTimer:(BOOL)enable
{
    if (!enable)
    {
        if (_timer)
        {
            [_timer invalidate];
            _timer = nil;
        }
    }
    else
    {
        if (!_timer)
        {
            _timer = [CPTimer scheduledTimerWithTimeInterval:0.01
                                                      target:self
                                                    selector:@selector(_runNextOpsInQueue)
                                                    userInfo:nil
                                                     repeats:YES];
        }
    }
}

- (void)addOperation:(CPOperation)anOperation
{
    [self willChangeValueForKey:@"operations"];
    [self willChangeValueForKey:@"operationCount"];
    [_operations addObject:anOperation];
    [self _sortOpsByPriority:_operations];
    [self didChangeValueForKey:@"operations"];
    [self didChangeValueForKey:@"operationCount"];
}

- (void)addOperations:(CPArray)ops waitUntilFinished:(BOOL)wait
{
    if (ops)
    {
        if (wait)
        {
            [self _sortOpsByPriority:ops];
            [self _runOpsSynchronously:ops];
        }

        [_operations addObjectsFromArray:ops];
        [self _sortOpsByPriority:_operations];
    }
}

- (void)addOperationWithFunction:(JSObject)aFunction
{
    [self addOperation:[CPFunctionOperation functionOperationWithFunction:aFunction]];
}

- (CPArray)operations
{
    return _operations;
}

- (int)operationCount
{
    if (_operations)
    {
        return [_operations count];
    }

    return 0;
}

- (void)cancelAllOperations
{
    if (_operations)
    {
        var i = 0,
            count = [_operations count];

        for (; i < count; i++)
        {
            [[_operations objectAtIndex:i] cancel];
        }
    }
}

- (void)waitUntilAllOperationsAreFinished
{
    // lets first stop the timer so it won't interfere
    [self _enableTimer:NO];
    [self _runOpsSynchronously:_operations];
    if (!_suspended)
    {
        [self _enableTimer:YES];
    }
}


- (int)maxConcurrentOperationCount
{
    return 1;
}

- (void)setSuspended:(BOOL)suspend
{
    _suspended = suspend;
    [self _enableTimer:!suspend];
}

- (BOOL)isSuspended
{
    return _suspended;
}

- (void)_sortOpsByPriority:(CPArray)someOps
{
    if (someOps)
    {
        [someOps sortUsingFunction:function(lhs, rhs)
        {
            if ([lhs queuePriority] < [rhs queuePriority])
            {
                return 1;
            }
            else
            {
                if ([lhs queuePriority] > [rhs queuePriority])
                {
                    return -1;
                }
                else
                {
                    return 0;
                }
            }
        }
        context:nil];
    }
}

- (void)_runOpsSynchronously:(CPArray)ops
{
    if (ops)
    {
        var keepGoing = YES;
        while (keepGoing)
        {
            var i = 0,
                count = [ops count];

            keepGoing = NO;

            // start the ones that are ready
            for (; i < count; i++)
            {
                var op = [ops objectAtIndex:i];
                if ([op isReady] && ![op isFinished] && ![op isExecuting])
                {
                    [op start];
                }
            }

            // make sure they are all done
            for (i = 0; i < count; i++)
            {
                var op = [ops objectAtIndex:i];
                if (![op isFinished] && ![op isCancelled])
                {
                    keepGoing = YES;
                }
            }
        }
    }
}

+ (CPOperationQueue)mainQueue
{
    if (!cpOperationMainQueue)
    {
        cpOperationMainQueue = [[CPOperationQueue alloc] init];
        [cpOperationMainQueue setName:@"main"];
    }

    return cpOperationMainQueue;
}

+ (CPOperationQueue)currentQueue
{
    return [CPOperationQueue mainQueue];
}

@end

@implementation CPOperationQueue (CPSynthesizedAccessors)

- (CPString)name
{
    return _name;
}

- (void)setName:(CPString)aValue
{
    _name = aValue;
}

@end