Dictionary.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include "Dictionary.h"
#include "Hash.h"
#include "MutableArray.h"
#include "MutableDictionary.h"
#include "MutableString.h"

Go to the source code of this file.

Macros
#define	_Class   _Dictionary

Functions
Class *	_Dictionary (void)
static Array *	allKeys (const Dictionary *self)
static void	allKeys_enumerator (const Dictionary *dict, ident obj, ident key, ident data)
	DictionaryEnumerator for allKeys. More...
static Array *	allObjects (const Dictionary *self)
static void	allObjects_enumerator (const Dictionary *dict, ident obj, ident key, ident data)
	DictionaryEnumerator for allObjects. More...
static _Bool	containsKey (const Dictionary *self, const ident key)
static _Bool	containsKeyPath (const Dictionary *self, const char *path)
static Object *	copy (const Object *self)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static void	description_enumerator (const Dictionary *dict, ident obj, ident key, ident data)
	A DictionaryEnumerator for description. More...
static Dictionary *	dictionaryWithDictionary (const Dictionary *dictionary)
static Dictionary *	dictionaryWithObjectsAndKeys (ident obj,...)
static void	enumerateObjectsAndKeys (const Dictionary *self, DictionaryEnumerator enumerator, ident data)
static Dictionary *	filterObjectsAndKeys (const Dictionary *self, DictionaryPredicate predicate, ident data)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static Dictionary *	initWithDictionary (Dictionary *self, const Dictionary *dictionary)
static Dictionary *	initWithObjectsAndKeys (Dictionary *self,...)
static _Bool	isEqual (const Object *self, const Object *other)
static MutableDictionary *	mutableCopy (const Dictionary *self)
static ident	objectForKey (const Dictionary *self, const ident key)
static ident	objectForKeyPath (const Dictionary *self, const char *path)

Macro Definition Documentation

_Class

#define _Class   _Dictionary

Definition at line 34 of file Dictionary.c.

Function Documentation

_Dictionary()

Class * _Dictionary

(

void

)

Definition at line 451 of file Dictionary.c.

                         {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Dictionary",
            .superclass = _Object(),
            .instanceSize = sizeof(Dictionary),
            .interfaceOffset = offsetof(Dictionary, interface),
            .interfaceSize = sizeof(DictionaryInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}

allKeys()

static Array * allKeys ( const Dictionary *  self )

static

Definition at line 169 of file Dictionary.c.

                                              {
 
    MutableArray *keys = $(alloc(MutableArray), initWithCapacity, self->count);
 
    $(self, enumerateObjectsAndKeys, allKeys_enumerator, keys);
 
    return (Array *) keys;
}

allKeys_enumerator()

static void allKeys_enumerator ( const Dictionary *  dict, ident  obj, ident  key, ident  data  )

static

DictionaryEnumerator for allKeys.

Definition at line 161 of file Dictionary.c.

                                                                                         {
    $((MutableArray *) data, addObject, key);
}

allObjects()

static Array * allObjects ( const Dictionary *  self )

static

Definition at line 189 of file Dictionary.c.

                                                 {
 
    MutableArray *objects = $(alloc(MutableArray), initWithCapacity, self->count);
 
    $(self, enumerateObjectsAndKeys, allObjects_enumerator, objects);
 
    return (Array *) objects;
}

allObjects_enumerator()

static void allObjects_enumerator ( const Dictionary *  dict, ident  obj, ident  key, ident  data  )

static

DictionaryEnumerator for allObjects.

Definition at line 181 of file Dictionary.c.

                                                                                            {
    $((MutableArray *) data, addObject, obj);
}

containsKey()

static _Bool containsKey ( const Dictionary *  self, const ident  key  )

static

Definition at line 202 of file Dictionary.c.

                                                                  {
    return $(self, objectForKey, key) != NULL;
}

containsKeyPath()

static _Bool containsKeyPath ( const Dictionary *  self, const char *  path  )

static

Definition at line 210 of file Dictionary.c.

                                                                       {
    return $(self, objectForKeyPath, path) != NULL;
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 41 of file Dictionary.c.

                                        {
 
    const Dictionary *this = (Dictionary *) self;
 
    Dictionary *that = $(alloc(Dictionary), initWithDictionary, this);
 
    return (Object *) that;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 53 of file Dictionary.c.

                                  {
 
    Dictionary *this = (Dictionary *) self;
 
    for (size_t i = 0; i < this->capacity; i++) {
        release(this->elements[i]);
    }
 
    free(this->elements);
 
    super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 85 of file Dictionary.c.

                                               {
 
    const Dictionary *this = (Dictionary *) self;
 
    MutableString *desc = $(alloc(MutableString), init);
 
    $(desc, appendCharacters, "{");
 
    $(this, enumerateObjectsAndKeys, description_enumerator, desc);
 
    $(desc, appendCharacters, "}");
 
    return (String *) desc;
}

description_enumerator()

static void description_enumerator ( const Dictionary *  dict, ident  obj, ident  key, ident  data  )

static

A DictionaryEnumerator for description.

Definition at line 69 of file Dictionary.c.

                                                                                             {
 
    MutableString *desc = (MutableString *) data;
 
    String *objDesc = $((Object *) obj, description);
    String *keyDesc = $((Object *) key, description);
 
    $(desc, appendFormat, "%s: %s, ", keyDesc->chars, objDesc->chars);
 
    release(objDesc);
    release(keyDesc);
}

dictionaryWithDictionary()

static Dictionary * dictionaryWithDictionary ( const Dictionary *  dictionary )

static

Definition at line 218 of file Dictionary.c.

                                                                          {
 
    return $(alloc(Dictionary), initWithDictionary, dictionary);
}

dictionaryWithObjectsAndKeys()

static Dictionary * dictionaryWithObjectsAndKeys ( ident  obj,   ...  )

static

Definition at line 227 of file Dictionary.c.

                                                                {
 
    Dictionary *dict = (Dictionary *) $((Object *) alloc(Dictionary), init);
    if (dict) {
 
        va_list args;
        va_start(args, obj);
 
        while (obj) {
            ident key = va_arg(args, ident);
 
            $$(MutableDictionary, setObjectForKey, (MutableDictionary *) dict, obj, key);
 
            obj = va_arg(args, ident);
        }
 
        va_end(args);
    }
 
    return dict;
}

enumerateObjectsAndKeys()

static void enumerateObjectsAndKeys ( const Dictionary *  self, DictionaryEnumerator  enumerator, ident  data  )

static

Definition at line 253 of file Dictionary.c.

                    {
 
    assert(enumerator);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j += 2) {
 
                ident key = $(array, objectAtIndex, j);
                ident obj = $(array, objectAtIndex, j + 1);
 
                enumerator(self, obj, key, data);
            }
        }
    }
}

filterObjectsAndKeys()

static Dictionary * filterObjectsAndKeys ( const Dictionary *  self, DictionaryPredicate  predicate, ident  data  )

static

Definition at line 278 of file Dictionary.c.

                                                                                                           {
 
    assert(predicate);
 
    MutableDictionary *dictionary = $(alloc(MutableDictionary), init);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j += 2) {
 
                ident key = $(array, objectAtIndex, j);
                ident obj = $(array, objectAtIndex, j + 1);
 
                if (predicate(obj, key, data)) {
                    $(dictionary, setObjectForKey, obj, key);
                }
            }
        }
    }
 
    return (Dictionary *) dictionary;
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 103 of file Dictionary.c.

                                    {
 
    const Dictionary *this = (Dictionary *) self;
 
    int hash = HashForInteger(HASH_SEED, this->count);
 
    for (size_t i = 0; i < this->capacity; i++) {
        if (this->elements[i]) {
            hash = HashForObject(hash, this->elements[i]);
        }
    }
 
    return hash;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 424 of file Dictionary.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->copy = copy;
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
    ((ObjectInterface *) clazz->interface)->description = description;
    ((ObjectInterface *) clazz->interface)->hash = hash;
    ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
 
    ((DictionaryInterface *) clazz->interface)->allKeys = allKeys;
    ((DictionaryInterface *) clazz->interface)->allObjects = allObjects;
    ((DictionaryInterface *) clazz->interface)->containsKey = containsKey;
    ((DictionaryInterface *) clazz->interface)->containsKeyPath = containsKeyPath;
    ((DictionaryInterface *) clazz->interface)->dictionaryWithDictionary = dictionaryWithDictionary;
    ((DictionaryInterface *) clazz->interface)->dictionaryWithObjectsAndKeys = dictionaryWithObjectsAndKeys;
    ((DictionaryInterface *) clazz->interface)->enumerateObjectsAndKeys = enumerateObjectsAndKeys;
    ((DictionaryInterface *) clazz->interface)->filterObjectsAndKeys = filterObjectsAndKeys;
    ((DictionaryInterface *) clazz->interface)->initWithDictionary = initWithDictionary;
    ((DictionaryInterface *) clazz->interface)->initWithObjectsAndKeys = initWithObjectsAndKeys;
    ((DictionaryInterface *) clazz->interface)->mutableCopy = mutableCopy;
    ((DictionaryInterface *) clazz->interface)->objectForKey = objectForKey;
    ((DictionaryInterface *) clazz->interface)->objectForKeyPath = objectForKeyPath;
}

initWithDictionary()

static Dictionary * initWithDictionary ( Dictionary *  self, const Dictionary *  dictionary  )

static

Definition at line 308 of file Dictionary.c.

                                                                                      {
 
    self = (Dictionary *) super(Object, self, init);
    if (self) {
        if (dictionary) {
 
            self->capacity = dictionary->capacity;
 
            self->elements = calloc(self->capacity, sizeof(ident));
            assert(self->elements);
 
            for (size_t i = 0; i < dictionary->capacity; i++) {
 
                Array *array = dictionary->elements[i];
                if (array) {
                    self->elements[i] = $((Object *) array, copy);
                }
            }
 
            self->count = dictionary->count;
        }
    }
 
    return self;
}

initWithObjectsAndKeys()

static Dictionary * initWithObjectsAndKeys ( Dictionary *  self,   ...  )

static

Definition at line 338 of file Dictionary.c.

                                                                 {
 
    self = (Dictionary *) super(Object, self, init);
    if (self) {
 
        va_list args;
        va_start(args, self);
 
        while (true) {
 
            ident obj = va_arg(args, ident);
            if (obj) {
 
                ident key = va_arg(args, ident);
                $$(MutableDictionary, setObjectForKey, (MutableDictionary *) self, obj, key);
            } else {
                break;
            }
        }
 
        va_end(args);
    }
 
    return self;
}

isEqual()

static _Bool isEqual ( const Object *  self, const Object *  other  )

static

See also

Object::isEqual(const Object *, const Object *)

Definition at line 121 of file Dictionary.c.

                                                              {
 
    if (super(Object, self, isEqual, other)) {
        return true;
    }
 
    if (other && $(other, isKindOfClass, _Dictionary())) {
 
        const Dictionary *this = (Dictionary *) self;
        const Dictionary *that = (Dictionary *) other;
 
        if (this->count == that->count) {
 
            Array *keys = $(this, allKeys);
 
            for (size_t i = 0; i < keys->count; i++) {
                const ident key = $(keys, objectAtIndex, i);
 
                const Object *thisObject = $(this, objectForKey, key);
                const Object *thatObject = $(that, objectForKey, key);
 
                if ($(thisObject, isEqual, thatObject) == false) {
                    release(keys);
                    return false;
                }
            }
 
            release(keys);
            return true;
        }
    }
 
    return false;
}

mutableCopy()

static MutableDictionary * mutableCopy ( const Dictionary *  self )

static

Definition at line 368 of file Dictionary.c.

                                                              {
 
    MutableDictionary *copy = $(alloc(MutableDictionary), initWithCapacity, self->count);
    if (copy) {
        $(copy, addEntriesFromDictionary, self);
    }
 
    return copy;
}

objectForKey()

static ident objectForKey ( const Dictionary *  self, const ident  key  )

static

Definition at line 382 of file Dictionary.c.

                                                                   {
 
    if (self->capacity == 0) {
        return NULL;
    }
    
    const size_t bin = HashForObject(HASH_SEED, key) % self->capacity;
 
    Array *array = self->elements[bin];
    if (array) {
 
        const ssize_t index = $(array, indexOfObject, key);
        if (index > -1 && (index & 1) == 0) {
            return $(array, objectAtIndex, index + 1);
        }
    }
 
    return NULL;
}

objectForKeyPath()

static ident objectForKeyPath ( const Dictionary *  self, const char *  path  )

static

Definition at line 406 of file Dictionary.c.

                                                                        {
 
    assert(path);
 
    String *key = str(path);
 
    ident obj = $(self, objectForKey, key);
 
    release(key);
 
    return obj;
}