CPMutableArray.j

Go to the documentation of this file.

@implementation CPMutableArray : CPArray
{
    id __doxygen__;
}

// Creating arrays
+ (CPArray)arrayWithCapacity:(CPUInteger)aCapacity
{
    return [[self alloc] initWithCapacity:aCapacity];
}

/*- (id)initWithCapacity:(CPUInteger)aCapacity
{
    return self;
}*/

// Adding and replacing objects
- (void)addObject:(id)anObject
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

- (void)addObjectsFromArray:(CPArray)anArray
{
    var index = 0,
        count = [anArray count];

    for (; index < count; ++index)
        [self addObject:[anArray objectAtIndex:index]];
}

- (void)insertObject:(id)anObject atIndex:(CPUInteger)anIndex
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

- (void)insertObjects:(CPArray)objects atIndexes:(CPIndexSet)indexes
{
    var indexesCount = [indexes count],
        objectsCount = [objects count];

    if (indexesCount !== objectsCount)
        [CPException raise:CPRangeException reason:"the counts of the passed-in array (" + objectsCount + ") and index set (" + indexesCount + ") must be identical."];

    var lastIndex = [indexes lastIndex];

    if (lastIndex >= [self count] + indexesCount)
        [CPException raise:CPRangeException reason:"the last index (" + lastIndex + ") must be less than the sum of the original count (" + [self count] + ") and the insertion count (" + indexesCount + ")."];

    var index = 0,
        currentIndex = [indexes firstIndex];

    for (; index < objectsCount; ++index, currentIndex = [indexes indexGreaterThanIndex:currentIndex])
        [self insertObject:[objects objectAtIndex:index] atIndex:currentIndex];
}

- (CPUInteger)insertObject:(id)anObject inArraySortedByDescriptors:(CPArray)descriptors
{
    var index,
        count = [descriptors count];

    if (count)
        index = [self indexOfObject:anObject
                      inSortedRange:nil
                            options:CPBinarySearchingInsertionIndex
                    usingComparator:function(lhs, rhs)
        {
            var index = 0,
                result = CPOrderedSame;

            while (index < count && ((result = [[descriptors objectAtIndex:index] compareObject:lhs withObject:rhs]) === CPOrderedSame))
                ++index;

            return result;
        }];

    else
        index = [self count];

    [self insertObject:anObject atIndex:index];

    return index;
}

- (void)replaceObjectAtIndex:(CPUInteger)anIndex withObject:(id)anObject
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

- (void)replaceObjectsAtIndexes:(CPIndexSet)indexes withObjects:(CPArray)objects
{
    var i = 0,
        index = [indexes firstIndex];

    while (index !== CPNotFound)
    {
        [self replaceObjectAtIndex:index withObject:[objects objectAtIndex:i++]];
        index = [indexes indexGreaterThanIndex:index];
    }
}

- (void)replaceObjectsInRange:(CPRange)aRange withObjectsFromArray:(CPArray)anArray range:(CPRange)otherRange
{
    [self removeObjectsInRange:aRange];

    if (otherRange && (otherRange.location !== 0 || otherRange.length !== [anArray count]))
        anArray = [anArray subarrayWithRange:otherRange];

    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(aRange.location, [anArray count])];

    [self insertObjects:anArray atIndexes:indexes];
}

- (void)replaceObjectsInRange:(CPRange)aRange withObjectsFromArray:(CPArray)anArray
{
    [self replaceObjectsInRange:aRange withObjectsFromArray:anArray range:nil];
}

- (void)setArray:(CPArray)anArray
{
    if (self === anArray)
        return;

    [self removeAllObjects];
    [self addObjectsFromArray:anArray];
}

// Removing Objects
- (void)removeAllObjects
{
    while ([self count])
        [self removeLastObject];
}

- (void)removeLastObject
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

- (void)removeObject:(id)anObject
{
    [self removeObject:anObject inRange:CPMakeRange(0, [self count])];
}

- (void)removeObject:(id)anObject inRange:(CPRange)aRange
{
    var index;

    while ((index = [self indexOfObject:anObject inRange:aRange]) != CPNotFound)
    {
        [self removeObjectAtIndex:index];
        aRange = CPIntersectionRange(CPMakeRange(index, [self count] - index), aRange);
    }
}

- (void)removeObjectAtIndex:(CPUInteger)anIndex
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

- (void)removeObjectsAtIndexes:(CPIndexSet)anIndexSet
{
    var index = [anIndexSet lastIndex];

    while (index !== CPNotFound)
    {
        [self removeObjectAtIndex:index];
        index = [anIndexSet indexLessThanIndex:index];
    }
}

- (void)removeObjectIdenticalTo:(id)anObject
{
    [self removeObjectIdenticalTo:anObject inRange:CPMakeRange(0, [self count])];
}

- (void)removeObjectIdenticalTo:(id)anObject inRange:(CPRange)aRange
{
    var index,
        count = [self count];

    while ((index = [self indexOfObjectIdenticalTo:anObject inRange:aRange]) !== CPNotFound)
    {
        [self removeObjectAtIndex:index];
        aRange = CPIntersectionRange(CPMakeRange(index, (--count) - index), aRange);
    }
}

- (void)removeObjectsInArray:(CPArray)anArray
{
    var index = 0,
        count = [anArray count];

    for (; index < count; ++index)
        [self removeObject:[anArray objectAtIndex:index]];
}

- (void)removeObjectsInRange:(CPRange)aRange
{
    var index = aRange.location,
        count = CPMaxRange(aRange);

    while (count-- > index)
        [self removeObjectAtIndex:index];
}

// Rearranging objects
- (void)exchangeObjectAtIndex:(CPUInteger)anIndex withObjectAtIndex:(CPUInteger)otherIndex
{
    if (anIndex === otherIndex)
        return;

    var temporary = [self objectAtIndex:anIndex];

    [self replaceObjectAtIndex:anIndex withObject:[self objectAtIndex:otherIndex]];
    [self replaceObjectAtIndex:otherIndex withObject:temporary];
}

- (void)sortUsingDescriptors:(CPArray)descriptors
{
    var i = [descriptors count],
        jsDescriptors = [];

    // Revert the order of the descriptors
    while (i--)
    {
        var d = [descriptors objectAtIndex:i];
        [jsDescriptors addObject:{ "k": [d key], "a": [d ascending], "s": [d selector]}];
    }
    sortArrayUsingJSDescriptors(self, jsDescriptors);
}

- (void)sortUsingFunction:(Function)aFunction context:(id)aContext
{
    sortArrayUsingFunction(self, aFunction, aContext);
}

- (void)sortUsingSelector:(SEL)aSelector
{
    sortArrayUsingFunction(self, selectorCompare, aSelector);
}

@end

@implementation CPArray (CPMutableCopying)

- (id)mutableCopy
{
    var r = [CPMutableArray new];
    [r addObjectsFromArray:self];
    return r;
}

@end

var selectorCompare = function(object1, object2, selector)
{
    return [object1 performSelector:selector withObject:object2];
};

var sortArrayUsingFunction = function(array, aFunction, aContext)
{
    var h,
        i,
        j,
        k,
        l,
        m,
        n = array.length,
        o;

    var A,
        B = [];

    for (h = 1; h < n; h += h)
    {
        for (m = n - 1 - h; m >= 0; m -= h + h)
        {
            l = m - h + 1;
            if (l < 0)
                l = 0;

            for (i = 0, j = l; j <= m; i++, j++)
                B[i] = array[j];

            for (i = 0, k = l; k < j && j <= m + h; k++)
            {
                A = array[j];
                o = aFunction(A, B[i], aContext);

                if (o >= 0)
                    array[k] = B[i++];
                else
                {
                    array[k] = A;
                    j++;
                }
            }

            while (k < j)
                array[k++] = B[i++];
        }
    }
}

// This is for speed
var CPMutableArrayNull = [CPNull null];

// Observe that the sort descriptors has the reversed order by the caller
var sortArrayUsingJSDescriptors = function(a, d)
{
    var h,
        i,
        j,
        k,
        l,
        m,
        n = a.length,
        dl = d.length - 1,
        o,
        c = {};

    var A,
        B = [],
        C1,
        C2,
        cn,
        aUID,
        bUID,
        key,
        dd,
        value1,
        value2,
        cpNull = CPMutableArrayNull;

    if (dl < 0)
        return;

    for (h = 1; h < n; h += h)
    {
        for (m = n - 1 - h; m >= 0; m -= h + h)
        {
            l = m - h + 1;

            if (l < 0)
                l = 0;

            for (i = 0, j = l; j <= m; i++, j++)
                B[i] = a[j];

            for (i = 0, k = l; k < j && j <= m + h; k++)
            {
                A = a[j];
                aUID = A._UID;

                if (!aUID)
                    aUID = [A UID];

                C1 = c[aUID];

                if (!C1)
                {
                    C1 = {};
                    cn = dl;

                    do
                    {
                        key = d[cn].k;
                        C1[key] = [A valueForKeyPath:key];
                    } while (cn--)

                    c[aUID] = C1;
                }

                bUID = B[i]._UID;

                if (!bUID)
                    bUID = [B[i] UID];

                C2 = c[bUID];

                if (!C2)
                {
                    C2 = {};
                    cn = dl;

                    do
                    {
                        key = d[cn].k;
                        C2[key] = [B[i] valueForKeyPath:key];
                    } while (cn--)

                    c[bUID] = C2;
                }

                cn = dl;

                do
                {
                    dd = d[cn];
                    key = dd.k;
                    value1 = C1[key];
                    value2 = C2[key];
                    if (value1 === nil || value1 === cpNull)
                        o = value2 === nil || value2 === cpNull ? CPOrderedSame : CPOrderedAscending;
                    else
                        o = value2 === nil || value2 === cpNull ? CPOrderedDescending : value1.isa.objj_msgSend1(value1, dd.s, value2);

                    if (o && !dd.a)
                        o = -o;
                } while (cn-- && o == CPOrderedSame)

                if (o >= 0)
                    a[k] = B[i++];
                else
                {
                    a[k] = A;
                    j++;
                }
            }

            while (k < j)
                a[k++] = B[i++];
        }
    }
}