/Users/rquesada/progs/cocos2d-iphone/cocos2d/Support/ccCArray.h

Go to the documentation of this file.

/* Copyright (c) 2007 Scott Lembcke
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef CC_ARRAY_H
#define CC_ARRAY_H

#import <Foundation/Foundation.h>

#import <stdlib.h>
#import <string.h>


#pragma mark -
#pragma mark ccArray for Objects

// Easy integration     
#define CCARRAYDATA_FOREACH(__array__, __object__)                                                                                                                      \
__object__=__array__->arr[0]; for(NSUInteger i=0, num=__array__->num; i<num; i++, __object__=__array__->arr[i]) \


typedef struct ccArray {
        NSUInteger num, max;
        id *arr;
} ccArray;

static inline ccArray* ccArrayNew(NSUInteger capacity) {
        if (capacity == 0)
                capacity = 1; 
        
        ccArray *arr = (ccArray*)malloc( sizeof(ccArray) );
        arr->num = 0;
        arr->arr =  (id*) malloc( capacity * sizeof(id) );
        arr->max = capacity;
        
        return arr;
}

static inline void ccArrayRemoveAllObjects(ccArray *arr);

static inline void ccArrayFree(ccArray *arr)
{
        if( arr == nil ) return;
        
        ccArrayRemoveAllObjects(arr);
        
        free(arr->arr);
        free(arr);
}

static inline void ccArrayDoubleCapacity(ccArray *arr)
{
        arr->max *= 2;
        id *newArr = (id *)realloc( arr->arr, arr->max * sizeof(id) );
        // will fail when there's not enough memory
    NSCAssert(newArr != NULL, @"ccArrayDoubleCapacity failed. Not enough memory");
        arr->arr = newArr;
}

static inline void ccArrayEnsureExtraCapacity(ccArray *arr, NSUInteger extra)
{
        while (arr->max < arr->num + extra)
                ccArrayDoubleCapacity(arr);
}

static inline void ccArrayShrink(ccArray *arr)
{
    NSUInteger newSize;
        
        //only resize when necessary
        if (arr->max > arr->num && !(arr->num==0 && arr->max==1))
        {
                if (arr->num!=0) 
                {
                        newSize=arr->num;
                        arr->max=arr->num; 
                }
                else 
                {//minimum capacity of 1, with 0 elements the array would be free'd by realloc
                        newSize=1;
                        arr->max=1;
                }
                
                arr->arr = (id*) realloc(arr->arr,newSize * sizeof(id) );
                NSCAssert(arr->arr!=NULL,@"could not reallocate the memory");
        }
} 

static inline NSUInteger ccArrayGetIndexOfObject(ccArray *arr, id object)
{
        for( NSUInteger i = 0; i < arr->num; i++)
                if( arr->arr[i] == object ) return i;
    
        return NSNotFound;
}

static inline BOOL ccArrayContainsObject(ccArray *arr, id object)
{
        return ccArrayGetIndexOfObject(arr, object) != NSNotFound;
}

static inline void ccArrayAppendObject(ccArray *arr, id object)
{
        arr->arr[arr->num] = [object retain];
        arr->num++;
}

static inline void ccArrayAppendObjectWithResize(ccArray *arr, id object)
{
        ccArrayEnsureExtraCapacity(arr, 1);
        ccArrayAppendObject(arr, object);
}

static inline void ccArrayAppendArray(ccArray *arr, ccArray *plusArr)
{
        for( NSUInteger i = 0; i < plusArr->num; i++)
                ccArrayAppendObject(arr, plusArr->arr[i]);
}

static inline void ccArrayAppendArrayWithResize(ccArray *arr, ccArray *plusArr)
{
        ccArrayEnsureExtraCapacity(arr, plusArr->num);
        ccArrayAppendArray(arr, plusArr);
}

static inline void ccArrayInsertObjectAtIndex(ccArray *arr, id object, NSUInteger index)
{
        NSCAssert(index<=arr->num, @"Invalid index. Out of bounds");
        
        ccArrayEnsureExtraCapacity(arr, 1);
        
        NSUInteger remaining = arr->num - index;
        if( remaining > 0)
                memmove(&arr->arr[index+1], &arr->arr[index], sizeof(id) * remaining );
        
        arr->arr[index] = [object retain];
        arr->num++;
}

static inline void ccArraySwapObjectsAtIndexes(ccArray *arr, NSUInteger index1, NSUInteger index2)
{
        NSCAssert(index1 < arr->num, @"(1) Invalid index. Out of bounds");
        NSCAssert(index2 < arr->num, @"(2) Invalid index. Out of bounds");
        
        id object1 = arr->arr[index1];
    
        arr->arr[index1] = arr->arr[index2];
        arr->arr[index2] = object1;
}

static inline void ccArrayRemoveAllObjects(ccArray *arr)
{
        while( arr->num > 0 )
                [arr->arr[--arr->num] release]; 
}

static inline void ccArrayRemoveObjectAtIndex(ccArray *arr, NSUInteger index)
{
        [arr->arr[index] release];
        arr->num--;
        
        NSUInteger remaining = arr->num - index;
        if(remaining>0)
                memmove(&arr->arr[index], &arr->arr[index+1], remaining * sizeof(id));
}

static inline void ccArrayFastRemoveObjectAtIndex(ccArray *arr, NSUInteger index)
{
        [arr->arr[index] release];
        NSUInteger last = --arr->num;
        arr->arr[index] = arr->arr[last];
}

static inline void ccArrayFastRemoveObject(ccArray *arr, id object)
{
        NSUInteger index = ccArrayGetIndexOfObject(arr, object);
        if (index != NSNotFound)
                ccArrayFastRemoveObjectAtIndex(arr, index);
}

static inline void ccArrayRemoveObject(ccArray *arr, id object)
{
        NSUInteger index = ccArrayGetIndexOfObject(arr, object);
        if (index != NSNotFound)
                ccArrayRemoveObjectAtIndex(arr, index);
}

static inline void ccArrayRemoveArray(ccArray *arr, ccArray *minusArr)
{
        for( NSUInteger i = 0; i < minusArr->num; i++)
                ccArrayRemoveObject(arr, minusArr->arr[i]);
}

static inline void ccArrayFullRemoveArray(ccArray *arr, ccArray *minusArr)
{
        NSUInteger back = 0;
        
        for( NSUInteger i = 0; i < arr->num; i++) {
                if( ccArrayContainsObject(minusArr, arr->arr[i]) ) {
                        [arr->arr[i] release];
                        back++;
                } else
                        arr->arr[i - back] = arr->arr[i];
        }
        
        arr->num -= back;
}

static inline void ccArrayMakeObjectsPerformSelector(ccArray *arr, SEL sel)
{
        for( NSUInteger i = 0; i < arr->num; i++)
                [arr->arr[i] performSelector:sel];
}

static inline void ccArrayMakeObjectsPerformSelectorWithObject(ccArray *arr, SEL sel, id object)
{
        for( NSUInteger i = 0; i < arr->num; i++)
                [arr->arr[i] performSelector:sel withObject:object];
}


#pragma mark -
#pragma mark ccCArray for Values (c structures)

typedef ccArray ccCArray;

static inline void ccCArrayRemoveAllValues(ccCArray *arr);

static inline ccCArray* ccCArrayNew(NSUInteger capacity) {
        if (capacity == 0)
                capacity = 1; 
        
        ccCArray *arr = (ccCArray*)malloc( sizeof(ccCArray) );
        arr->num = 0;
        arr->arr =  (id*) malloc( capacity * sizeof(id) );
        arr->max = capacity;
        
        return arr;
}

static inline void ccCArrayFree(ccCArray *arr)
{
        if( arr == nil ) return;
        
        ccCArrayRemoveAllValues(arr);
        
        free(arr->arr);
        free(arr);
}

static inline void ccCArrayDoubleCapacity(ccCArray *arr)
{
        ccArrayDoubleCapacity(arr);
}

static inline void ccCArrayEnsureExtraCapacity(ccCArray *arr, NSUInteger extra)
{
        ccArrayEnsureExtraCapacity(arr,extra);
}

static inline NSUInteger ccCArrayGetIndexOfValue(ccCArray *arr, void* value)
{
        for( NSUInteger i = 0; i < arr->num; i++)
                if( arr->arr[i] == value ) return i;
        return NSNotFound;
}

static inline BOOL ccCArrayContainsValue(ccCArray *arr, void* value)
{
        return ccCArrayGetIndexOfValue(arr, value) != NSNotFound;
}

static inline void ccCArrayInsertValueAtIndex( ccCArray *arr, void *value, NSUInteger index)
{
        NSCAssert( index < arr->max, @"ccCArrayInsertValueAtIndex: invalid index");
        
        NSUInteger remaining = arr->num - index;
        
        // last Value doesn't need to be moved
        if( remaining > 0) {
                // tex coordinates
                memmove( &arr->arr[index+1],&arr->arr[index], sizeof(void*) * remaining );
        }
        
        arr->num++;     
        arr->arr[index] = (id) value;
}

static inline void ccCArrayAppendValue(ccCArray *arr, void* value)
{
        arr->arr[arr->num] = (id) value;
        arr->num++;
}

static inline void ccCArrayAppendValueWithResize(ccCArray *arr, void* value)
{
        ccCArrayEnsureExtraCapacity(arr, 1);
        ccCArrayAppendValue(arr, value);
}

static inline void ccCArrayAppendArray(ccCArray *arr, ccCArray *plusArr)
{
        for( NSUInteger i = 0; i < plusArr->num; i++)
                ccCArrayAppendValue(arr, plusArr->arr[i]);
}

static inline void ccCArrayAppendArrayWithResize(ccCArray *arr, ccCArray *plusArr)
{
        ccCArrayEnsureExtraCapacity(arr, plusArr->num);
        ccCArrayAppendArray(arr, plusArr);
}

static inline void ccCArrayRemoveAllValues(ccCArray *arr)
{
        arr->num = 0;
}

static inline void ccCArrayRemoveValueAtIndex(ccCArray *arr, NSUInteger index)
{       
        for( NSUInteger last = --arr->num; index < last; index++)
                arr->arr[index] = arr->arr[index + 1];
}

static inline void ccCArrayFastRemoveValueAtIndex(ccCArray *arr, NSUInteger index)
{
        NSUInteger last = --arr->num;
        arr->arr[index] = arr->arr[last];
}

static inline void ccCArrayRemoveValue(ccCArray *arr, void* value)
{
        NSUInteger index = ccCArrayGetIndexOfValue(arr, value);
        if (index != NSNotFound)
                ccCArrayRemoveValueAtIndex(arr, index);
}

static inline void ccCArrayRemoveArray(ccCArray *arr, ccCArray *minusArr)
{
        for( NSUInteger i = 0; i < minusArr->num; i++)
                ccCArrayRemoveValue(arr, minusArr->arr[i]);
}

static inline void ccCArrayFullRemoveArray(ccCArray *arr, ccCArray *minusArr)
{
        NSUInteger back = 0;
        
        for( NSUInteger i = 0; i < arr->num; i++) {
                if( ccCArrayContainsValue(minusArr, arr->arr[i]) ) {
                        back++;
                } else
                        arr->arr[i - back] = arr->arr[i];
        }
        
        arr->num -= back;
}
#endif // CC_ARRAY_H