CPDictionary.j

Go to the documentation of this file.

/*
 * CPDictionary.j
 * Foundation
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * 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
 */


var CPDictionaryMaxDescriptionRecursion = 10;

@implementation CPDictionary : CPObject
{
    id __doxygen__;
}

/*
    @ignore
*/
+ (id)alloc
{
    var result = new CFMutableDictionary();
    result.isa = [self class];
    return result;
}

+ (id)dictionary
{
    return [[self alloc] init];
}

+ (id)dictionaryWithDictionary:(CPDictionary)aDictionary
{
    return [[self alloc] initWithDictionary:aDictionary];
}

+ (id)dictionaryWithObject:(id)anObject forKey:(id)aKey
{
    return [[self alloc] initWithObjects:[anObject] forKeys:[aKey]];
}

+ (id)dictionaryWithObjects:(CPArray)objects forKeys:(CPArray)keys
{
    return [[self alloc] initWithObjects:objects forKeys:keys];
}

+ (id)dictionaryWithJSObject:(JSObject)object
{
    return [self dictionaryWithJSObject:object recursively:NO];
}

+ (id)dictionaryWithJSObject:(JSObject)object recursively:(BOOL)recursively
{
    var key = "",
        dictionary = [[self alloc] init];

    for (key in object)
    {
        if (!object.hasOwnProperty(key))
            continue;

        var value = object[key];

        if (value === null)
        {
            [dictionary setObject:[CPNull null] forKey:key];
            continue;
        }

        if (recursively)
        {
            if (value.constructor === Object)
                value = [CPDictionary dictionaryWithJSObject:value recursively:YES];
            else if ([value isKindOfClass:CPArray])
            {
                var newValue = [],
                    i = 0,
                    count = value.length;

                for (; i < count; i++)
                {
                    var thisValue = value[i];

                    if (thisValue === null)
                    {
                        newValue.push([CPNull null]);
                    }
                    else
                    {
                        if (thisValue.constructor === Object)
                            newValue.push([CPDictionary dictionaryWithJSObject:thisValue recursively:YES]);
                        else
                            newValue.push(thisValue);
                    }
                }

                value = newValue;
            }
        }

        [dictionary setObject:value forKey:key];
    }

    return dictionary;
}

+ (id)dictionaryWithObjectsAndKeys:(id)firstObject, ...
{
    arguments[0] = [self alloc];
    arguments[1] = @selector(initWithObjectsAndKeys:);

    return objj_msgSend.apply(this, arguments);
}

- (id)initWithDictionary:(CPDictionary)aDictionary
{
    var key = "",
        dictionary = [[CPDictionary alloc] init];

    for (key in aDictionary._buckets)
        [dictionary setObject:[aDictionary objectForKey:key] forKey:key];

    return dictionary;
}

- (id)initWithObjects:(CPArray)objects forKeys:(CPArray)keyArray
{
    self = [super init];

    var i = [keyArray count];

    if ([objects count] != i)
        [CPException raise:CPInvalidArgumentException reason:[CPString stringWithFormat:@"Counts are different.(%d != %d)", [objects count], [keyArray count]]];

    if (self)
    {
        while (i--)
        {
            var value = objects[i],
                key = keyArray[i];

            if (value === nil)
                [CPException raise:CPInvalidArgumentException reason:@"Attempt to insert nil object from objects[" + i + @"]"];

            if (key === nil)
                [CPException raise:CPInvalidArgumentException reason:@"Attempt to insert nil key from keys[" + i + @"]"];

            [self setObject:value forKey:key];
        }
    }

    return self;
}

- (id)initWithObjectsAndKeys:(id)firstObject, ...
{
    var argCount = arguments.length;

    if (argCount % 2 !== 0)
        [CPException raise:CPInvalidArgumentException reason:"Key-value count is mismatched. (" + argCount + " arguments passed)"];

    self = [super init];

    if (self)
    {
        // The arguments array contains self and _cmd, so the first object is at position 2.
        while (argCount-- > 2)
        {
            var key = arguments[argCount--],
                value = arguments[argCount];

            if (value === nil)
                [CPException raise:CPInvalidArgumentException reason:@"Attempt to insert nil object from objects[" + ((argCount / 2) - 1) + @"]"];

            if (key === nil)
                [CPException raise:CPInvalidArgumentException reason:@"Attempt to insert nil key from keys[" + ((argCount / 2) - 1) + @"]"];

            [self setObject:value forKey:key];
        }
    }

    return self;
}

- (CPDictionary)copy
{
    return [CPDictionary dictionaryWithDictionary:self];
}

- (int)count
{
    return self._count;
}

- (CPArray)allKeys
{
    return [self._keys copy];
}

- (CPArray)allValues
{
    var keys = self._keys,
        index = keys.length,
        values = [];

    while (index--)
        values.push(self.valueForKey(keys[index]));

    return values;
}

- (CPArray)allKeysForObject:(id)anObject
{
    var keys = self._keys,
        count = keys.length,
        index = 0,
        matchingKeys = [],
        key = nil,
        value = nil;

    for (; index < count; ++index)
    {
        key = keys[index];
        value = self._buckets[key];

        if (value.isa && anObject && anObject.isa && [value respondsToSelector:@selector(isEqual:)] && [value isEqual:anObject])
            matchingKeys.push(key);
        else if (value === anObject)
            matchingKeys.push(key);
    }

    return matchingKeys;
}

- (CPArray)keysOfEntriesPassingTest:(Function /*(id key, id obj, @ref BOOL stop)*/)predicate
{
    return [self keysOfEntriesWithOptions:CPEnumerationNormal passingTest:predicate];
}

- (CPArray)keysOfEntriesWithOptions:(CPEnumerationOptions)options passingTest:(Function /*(id key, id obj, @ref BOOL stop)*/)predicate
{
    var keys = self._keys;

    if (options & CPEnumerationReverse)
    {
        var index = [keys count] - 1,
            stop = -1,
            increment = -1;
    }
    else
    {
        var index = 0,
            stop = [keys count],
            increment = 1;
    }

    var matchingKeys = [],
        key = nil,
        value = nil,
        shouldStop = NO,
        stopRef = @ref(shouldStop);

    for (; index !== stop; index += increment)
    {
        key = keys[index];
        value = self._buckets[key];

        if (predicate(key, value, stopRef))
            matchingKeys.push(key);

        if (shouldStop)
            break;
    }

    return matchingKeys;
}

- (CPArray)keysSortedByValueUsingComparator:(Function /*(id obj1, id obj2)*/)comparator
{
    return [[self allKeys] sortedArrayUsingFunction:function(a, b)
        {
            a = [self objectForKey:a];
            b = [self objectForKey:b];

            return comparator(a, b);
        }
    ];
}

- (CPArray)keysSortedByValueUsingSelector:(SEL)theSelector
{
    return [[self allKeys] sortedArrayUsingFunction:function(a, b)
        {
            a = [self objectForKey:a];
            b = [self objectForKey:b];

            return [a performSelector:theSelector withObject:b];
        }
    ];
}

- (CPEnumerator)keyEnumerator
{
    return [self._keys objectEnumerator];
}

- (CPEnumerator)objectEnumerator
{
    return [[_CPDictionaryValueEnumerator alloc] initWithDictionary:self];
}

- (BOOL)isEqualToDictionary:(CPDictionary)aDictionary
{
    if (self === aDictionary)
        return YES;

    var count = [self count];

    if (count !== [aDictionary count])
        return NO;

    var index = count,
        keys = self._keys;

    while (index--)
    {
        var currentKey = keys[index],
            lhsObject = self._buckets[currentKey],
            rhsObject = aDictionary._buckets[currentKey];

        if (lhsObject === rhsObject)
            continue;

        if (lhsObject && lhsObject.isa && rhsObject && rhsObject.isa && [lhsObject respondsToSelector:@selector(isEqual:)] && [lhsObject isEqual:rhsObject])
            continue;

        return NO;
    }

    return YES;
}

- (BOOL)isEqual:(id)anObject
{
    if (self === anObject)
        return YES;

    if (![anObject isKindOfClass:[CPDictionary class]])
        return NO;

    return [self isEqualToDictionary:anObject];
}

/*
    Instance.allKeysForObject(anObject)
    {
        var i= 0,
            keys= CPArray.array(),
            count= this.count();

        while ((i= this._objects.indexOfObjectInRage(0, count-i))!=CPNotFound) keys.addObject(this._keys[i]);

        return keys;
    }

    Instance.keysSortedByValueUsingSelector(aSelector)
    {
        var dictionary= this,
            objectSelector= function(rhs)
            {
                return aSelector.apply(dictionary.objectForKey(this), [dictionary.objectForKey(rhs)]);
            };

        return this._keys.sortedArrayUsingSelector(objectSelector);
    }
*/
- (id)objectForKey:(id)aKey
{
    var object = self._buckets[aKey];

    return (object === undefined) ? nil : object;
}
/*
    Instance.objectsForKeys(keys, aNotFoundMarker)
    {
        var i= keys.length,
            objects= CPArray.array();

        while (i--)
        {
            var object= this.objectForKey(keys[i]);
            objects.addObject(object==nil?aNotFoundMarker:object);
        }

        return objects;
    }

    Instance.valueForKey(aKey)
    {
        if (aKey.length && aKey[0]=="@") return this.objectForKey(aKey.substr(1));

        return base.valueForKey(aKey);
    }
*/
- (void)removeAllObjects
{
    self.removeAllValues();
}

- (void)removeObjectForKey:(id)aKey
{
    self.removeValueForKey(aKey);
}

- (void)removeObjectsForKeys:(CPArray)keysForRemoval
{
    var index = keysForRemoval.length;

    while (index--)
        [self removeObjectForKey:keysForRemoval[index]];
}

/*
    Instance.setDictionary(aDictionary)
    {
        this._keys= CPArray.arrayWithArray(aDictionary.allKeys());
        this._objects= CPArray.arrayWithArray(aDictionary.allValues());

        this._dictionary= { };

        var i= this._keys.count();
        while (i--) this._dictionary[this._keys[i]]= { object: this._objects[i], index: i };
    }
*/
- (void)setObject:(id)anObject forKey:(id)aKey
{
    if (aKey === nil)
        [CPException raise:CPInvalidArgumentException reason:@"key cannot be nil"];

    if (anObject === nil)
        [CPException raise:CPInvalidArgumentException reason:@"object cannot be nil (key: " + aKey + @")"];

    self.setValueForKey(aKey, anObject);
}

- (void)addEntriesFromDictionary:(CPDictionary)aDictionary
{
    if (!aDictionary)
        return;

    var keys = [aDictionary allKeys],
        index = [keys count];

    while (index--)
    {
        var key = keys[index];

        [self setObject:[aDictionary objectForKey:key] forKey:key];
    }
}

- (CPString)description
{
    var string = "@{",
        keys = [self allKeys],
        index = 0,
        count = self._count;

    keys.sort();

    for (; index < count; ++index)
    {
        if (index === 0)
            string += "\n";

        var key = keys[index],
            value = self.valueForKey(key);

        string += "    @\"" + key + "\": " + CPDescriptionOfObject(value, CPDictionaryMaxDescriptionRecursion).split("\n").join("\n    ") + (index + 1 < count ? "," : "") + "\n";
    }

    return string + "}";
}

- (BOOL)containsKey:(id)aKey
{
    var value = [self objectForKey:aKey];
    return ((value !== nil) && (value !== undefined));
}

- (void)enumerateKeysAndObjectsUsingBlock:(Function /*(id aKey, id anObject, @ref BOOL stop)*/)aFunction
{
    var shouldStop = NO,
        shouldStopRef = @ref(shouldStop),
        keys = self._keys,
        count = self._count;

    for (var index = 0; index < count; index++)
    {
        var key = keys[index],
            value = self.valueForKey(key);

        aFunction(key, value, shouldStopRef);

        if (shouldStop)
            return;
    }
}

- (void)enumerateKeysAndObjectsWithOptions:(CPEnumerationOptions)opts usingBlock:(Function /*(id aKey, id anObject, @ref BOOL stop)*/)aFunction
{
    // Ignore the options because neither option has an effect.
    // CPEnumerationReverse has no effect on enumerating a CPDictionary because dictionary enumeration is not ordered.
    // CPEnumerationConcurrent is not possible in a single threaded environment.
    [self enumerateKeysAndObjectsUsingBlock:aFunction];
}

@end

@implementation CPDictionary (CPCoding)

/*
    Initializes the dictionary by unarchiving the data from a coder.
    @param aCoder the coder from which the data will be unarchived.
    @return the initialized dictionary
*/
- (id)initWithCoder:(CPCoder)aCoder
{
    return [aCoder _decodeDictionaryOfObjectsForKey:@"CP.objects"];
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    [aCoder _encodeDictionaryOfObjects:self forKey:@"CP.objects"];
}

@end


/* @ignore */
@implementation _CPDictionaryValueEnumerator : CPEnumerator
{
    CPEnumerator    _keyEnumerator;
    CPDictionary    _dictionary;
}

- (id)initWithDictionary:(CPDictionary)aDictionary
{
    self = [super init];

    if (self)
    {
        _keyEnumerator = [aDictionary keyEnumerator];
        _dictionary = aDictionary;
    }

    return self;
}

- (id)nextObject
{
    var key = [_keyEnumerator nextObject];

    if (key === nil)
        return nil;

    return [_dictionary objectForKey:key];
}

@end


@implementation CPMutableDictionary : CPDictionary
{
    id __doxygen__;
}

@end

CFDictionary.prototype.isa = CPDictionary;
CFMutableDictionary.prototype.isa = CPMutableDictionary;