OOAsyncQueue Class Reference

#include <OOAsyncQueue.h>

Inheritance diagram for OOAsyncQueue:

Collaboration diagram for OOAsyncQueue:

Instance Methods
(BOOL)	- enqueue:
(id)	- dequeue
(id)	- tryDequeue
(BOOL)	- empty
(unsigned)	- count
(void)	- emptyQueue
(id)	- init [implementation]
(void)	- dealloc [implementation]
(NSString *)	- description [implementation]
(void)	- doEmptyQueueWithAcquiredLock [implementation]
(id)	- doDequeAndUnlockWithAcquiredLock [implementation]
(void)	- recycleElementWithAcquiredLock: [implementation]

Private Attributes
NSConditionLock *	_lock
struct OOAsyncQueueElement *	_head
struct OOAsyncQueueElement *	_tail
struct OOAsyncQueueElement *	_pool
unsigned	_elemCount
unsigned	_poolCount

Detailed Description

Definition at line 36 of file OOAsyncQueue.h.

Method Documentation

count

- (unsigned) count

Definition at line 64 of file OOAsyncQueue.m.

{
    return _elemCount;
}

dealloc

- (void) dealloc

implementation

Definition at line 64 of file OOAsyncQueue.m.

{
    OOAsyncQueueElement     *element = NULL;
    
    [_lock lock];
    
    if (_elemCount != 0)
    {
        OOLogWARN(@"asyncQueue.nonEmpty", @"%@ deallocated while non-empty, flushing.", self);
        [self doEmptyQueueWithAcquiredLock];
    }
    
    // Free element pool.
    while (_pool != NULL)
    {
        element = _pool;
        _pool = element->next;
        free(element);
    }
    
    [_lock unlockWithCondition:kConditionDead];
    [_lock release];
    
    [super dealloc];
}

dequeue

- (id) dequeue

Definition at line 64 of file OOAsyncQueue.m.

{
    [_lock lockWhenCondition:kConditionQueuedData];
    return [self doDequeAndUnlockWithAcquiredLock];
}

description

- (NSString *) description

implementation

Definition at line 64 of file OOAsyncQueue.m.

{
    // Don't bother locking, the value would be out of date immediately anyway.
    return [NSString stringWithFormat:@"<%@ %p>{%u elements}", [self class], self, _elemCount];
}

doDequeAndUnlockWithAcquiredLock

- (id) doDequeAndUnlockWithAcquiredLock

implementation

Provided by category OOAsyncQueue(OOPrivate).

Definition at line 64 of file OOAsyncQueue.m.

{
    OOAsyncQueueElement     *element = NULL;
    id                      result;
    
    if (_head == NULL)
    {
        // Can happen if you enter debugger.
        return nil;
    }
    
//  assert(_head != NULL);
    
    // Dequeue element.
    element = _head;
    _head = _head->next;
    if (_head == NULL)  _tail = NULL;
    --_elemCount;
    
    // Unpack payload.
    result = [element->object autorelease];
    
    // Recycle element.
    [self recycleElementWithAcquiredLock:element];
    
    // Ensure sane status.
    assert((_head == NULL && _tail == NULL && _elemCount == 0) || (_head != NULL && _tail != NULL && _elemCount != 0));
    
    // Unlock with appropriate state.
    [_lock unlockWithCondition:(_head == NULL) ? kConditionNoData : kConditionQueuedData];
    
    return result;
}

doEmptyQueueWithAcquiredLock

- (void) doEmptyQueueWithAcquiredLock

implementation

Provided by category OOAsyncQueue(OOPrivate).

Definition at line 64 of file OOAsyncQueue.m.

{
    OOAsyncQueueElement     *element = NULL;
    
    // Loop over queue.
    while (_head != NULL)
    {
        // Dequeue element.
        element = _head;
        _head = _head->next;
        --_elemCount;
        
        // We don't need the payload any longer.
        [element->object release];
        
        // Or the element.
        [self recycleElementWithAcquiredLock:element];
    }
    
    _tail = NULL;
}

empty

- (BOOL) empty

Definition at line 64 of file OOAsyncQueue.m.

{
    return _head != NULL;
}

emptyQueue

- (void) emptyQueue

Definition at line 64 of file OOAsyncQueue.m.

{
    [_lock lock];
    [self doEmptyQueueWithAcquiredLock];
    
    assert(_head == NULL && _tail == NULL && _elemCount == 0);
    [_lock unlockWithCondition:kConditionNoData];
}

enqueue:

- (BOOL) enqueue:

(id)

object

Definition at line 64 of file OOAsyncQueue.m.

               :(id)object
{
    OOAsyncQueueElement     *element = NULL;
    BOOL                    success = NO;
    
    if (EXPECT_NOT(object == nil))  return NO;
    
    [_lock lock];
    
    // Get an element.
    if (_pool != NULL)
    {
        element = _pool;
        _pool = element->next;
        --_poolCount;
    }
    else
    {
        element = AllocElement();
        if (element == NULL)  goto FAIL;
    }
    
    // Set element fields.
    element->object = [object retain];
    element->next = NULL;
    
    // Insert in queue.
    if (_head == NULL)
    {
        // Queue was empty, element is entire queue.
        _head = _tail = element;
        element->next = NULL;
        assert(_elemCount == 0);
        _elemCount = 1;
    }
    else
    {
        assert(_tail != NULL);
        assert(_tail->next == NULL);
        assert(_elemCount != 0);
        
        _tail->next = element;
        _tail = element;
        ++_elemCount;
    }
    success = YES;
    
FAIL:
    [_lock unlockWithCondition:kConditionQueuedData];
    return success;
}

init

- (id) init

implementation

Definition at line 64 of file OOAsyncQueue.m.

{
    self = [super init];
    if (self != nil)
    {
        _lock = [[NSConditionLock alloc] initWithCondition:kConditionNoData];
        [_lock setName:@"OOAsyncQueue lock"];
        if (_lock == nil)
        {
            [self release];
            self = nil;
        }
    }
    
    return self;
}

recycleElementWithAcquiredLock:

- (void) recycleElementWithAcquiredLock: (OOAsyncQueueElement *) element

implementation

Provided by category OOAsyncQueue(OOPrivate).

Definition at line 64 of file OOAsyncQueue.m.

                                      :(OOAsyncQueueElement *)element
{
    if (_poolCount < kMaxPoolElements)
    {
        // Add to pool for reuse.
        element->next = _pool;
        _pool = element;
        ++_poolCount;
    }
    else
    {
        // Delete.
        FreeElement(element);
    }
}

tryDequeue

- (id) tryDequeue

Definition at line 64 of file OOAsyncQueue.m.

{
#if OO_BUGGY_PTHREADS
/* pthread_mutex_trylock is buggy on 64-bit windows with the pthread
 * library in use, so avoid doing things which use it This is a little
 * more blocking, but no thread should be hanging on to _lock for very
 * long, so hopefully it won't be noticeable.
 */
    [_lock lock];
    if ([_lock condition] != kConditionQueuedData)
    {
        [_lock unlock];
        return NO;
    }
#else
    // Mac and Linux can do it properly
    if (![_lock tryLockWhenCondition:kConditionQueuedData])  return nil;
#endif
    return [self doDequeAndUnlockWithAcquiredLock];
}

Member Data Documentation

_elemCount

- (unsigned) _elemCount

private

Definition at line 43 of file OOAsyncQueue.h.

_head

- (struct OOAsyncQueueElement*) _head

private

Definition at line 40 of file OOAsyncQueue.h.

_lock

- (NSConditionLock*) _lock

private

Definition at line 39 of file OOAsyncQueue.h.

_pool

- (struct OOAsyncQueueElement *) _pool

private

Definition at line 42 of file OOAsyncQueue.h.

_poolCount

- (unsigned) _poolCount

private

Definition at line 44 of file OOAsyncQueue.h.

_tail

- (struct OOAsyncQueueElement *) _tail

private

Definition at line 41 of file OOAsyncQueue.h.

---

The documentation for this class was generated from the following files:

• src/Core/OOAsyncQueue.h
• src/Core/OOAsyncQueue.m