Array.c File Reference

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

Go to the source code of this file.

Macros
#define	_Class   _Array

Functions
Class *	_Array (void)
static Array *	arrayWithArray (const Array *array)
static Array *	arrayWithObjects (ident obj,...)
static Array *	arrayWithVaList (va_list args)
static String *	componentsJoinedByCharacters (const Array *self, const char *chars)
static String *	componentsJoinedByString (const Array *self, const String *string)
static _Bool	containsObject (const Array *self, const ident obj)
static Object *	copy (const Object *self)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static void	enumerateObjects (const Array *self, ArrayEnumerator enumerator, ident data)
static Array *	filteredArray (const Array *self, Predicate predicate, ident data)
static ident	findObject (const Array *self, Predicate predicate, ident data)
static ident	firstObject (const Array *self)
static int	hash (const Object *self)
static ssize_t	indexOfObject (const Array *self, const ident obj)
static void	initialize (Class *clazz)
static Array *	initWithArray (Array *self, const Array *array)
static Array *	initWithObjects (Array *self,...)
static Array *	initWithVaList (Array *self, va_list args)
static _Bool	isEqual (const Object *self, const Object *other)
static ident	lastObject (const Array *self)
static Array *	mappedArray (const Array *self, Functor functor, ident data)
static MutableArray *	mutableCopy (const Array *self)
static ident	objectAtIndex (const Array *self, size_t index)
static ident	reduce (const Array *self, Reducer reducer, ident accumulator, ident data)
static Array *	sortedArray (const Array *self, Comparator comparator)

Macro Definition Documentation

_Class

#define _Class   _Array

Definition at line 33 of file Array.c.

Function Documentation

_Array()

Class * _Array

(

void

)

Definition at line 470 of file Array.c.

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

arrayWithArray()

static Array * arrayWithArray ( const Array *  array )

static

Definition at line 133 of file Array.c.

                                                 {
 
    return $(alloc(Array), initWithArray, array);
}

arrayWithObjects()

static Array * arrayWithObjects ( ident  obj,   ...  )

static

Definition at line 142 of file Array.c.

                                               {
 
    Array *array = (Array *) super(Object, alloc(Array), init);
    if (array) {
        va_list args;
        va_start(args, obj);
 
        while (obj) {
            array->elements = realloc(array->elements, ++array->count * sizeof(ident));
            assert(array->elements);
 
            array->elements[array->count - 1] = retain(obj);
            obj = va_arg(args, ident);
        }
 
        va_end(args);
    }
 
    return array;
}

arrayWithVaList()

static Array * arrayWithVaList ( va_list  args )

static

Definition at line 167 of file Array.c.

                                            {
 
    return $(alloc(Array), initWithVaList, args);
}

componentsJoinedByCharacters()

static String * componentsJoinedByCharacters ( const Array *  self, const char *  chars  )

static

Definition at line 176 of file Array.c.

                                                                                  {
 
    MutableString *string = $(alloc(MutableString), init);
 
    for (size_t i = 0; i < self->count; i++) {
 
        String *desc = $((Object *) self->elements[i], description);
        $(string, appendString, desc);
 
        release(desc);
 
        if (i < self->count - 1) {
            $(string, appendCharacters, chars);
        }
    }
 
    return (String *) string;
}

componentsJoinedByString()

static String * componentsJoinedByString ( const Array *  self, const String *  string  )

static

Definition at line 200 of file Array.c.

                                                                                 {
    return $(self, componentsJoinedByCharacters, string->chars);
}

containsObject()

static _Bool containsObject ( const Array *  self, const ident  obj  )

static

Definition at line 208 of file Array.c.

                                                                {
 
    return $(self, indexOfObject, obj) != -1;
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 40 of file Array.c.

                                        {
 
    const Array *this = (Array *) self;
 
    return (Object *) $(alloc(Array), initWithArray, this);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 50 of file Array.c.

                                  {
 
    Array *this = (Array *) self;
 
    for (size_t i = 0; i < this->count; 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 66 of file Array.c.

                                               {
 
    String *components = $((Array *) self, componentsJoinedByCharacters, ", ");
 
    String *desc = $(alloc(String), initWithFormat, "[%s]", components->chars ?: "");
 
    release(components);
 
    return desc;
}

enumerateObjects()

static void enumerateObjects ( const Array *  self, ArrayEnumerator  enumerator, ident  data  )

static

Definition at line 217 of file Array.c.

                                                                                        {
 
    assert(enumerator);
 
    for (size_t i = 0; i < self->count; i++) {
        enumerator(self, self->elements[i], data);
    }
}

filteredArray()

static Array * filteredArray ( const Array *  self, Predicate  predicate, ident  data  )

static

Definition at line 230 of file Array.c.

                                                                                {
 
    assert(predicate);
 
    MutableArray *copy = $(self, mutableCopy);
 
    $(copy, filter, predicate, data);
 
    return (Array *) copy;
}

findObject()

static ident findObject ( const Array *  self, Predicate  predicate, ident  data  )

static

Definition at line 245 of file Array.c.

                                                                            {
 
    assert(predicate);
 
    for (size_t i = 0; i < self->count; i++) {
        if (predicate(self->elements[i], data)) {
            return self->elements[i];
        }
    }
 
    return NULL;
}

firstObject()

static ident firstObject ( const Array *  self )

static

Definition at line 262 of file Array.c.

                                            {
 
    return self->count ? $(self, objectAtIndex, 0) : NULL;
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 80 of file Array.c.

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

indexOfObject()

static ssize_t indexOfObject ( const Array *  self, const ident  obj  )

static

Definition at line 271 of file Array.c.

                                                                 {
 
    assert(obj);
 
    for (size_t i = 0; i < self->count; i++) {
        if ($((Object * ) self->elements[i], isEqual, obj)) {
            return i;
        }
    }
 
    return -1;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 436 of file Array.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;
 
    ((ArrayInterface *) clazz->interface)->arrayWithArray = arrayWithArray;
    ((ArrayInterface *) clazz->interface)->arrayWithObjects = arrayWithObjects;
    ((ArrayInterface *) clazz->interface)->arrayWithVaList = arrayWithVaList;
    ((ArrayInterface *) clazz->interface)->componentsJoinedByCharacters = componentsJoinedByCharacters;
    ((ArrayInterface *) clazz->interface)->componentsJoinedByString = componentsJoinedByString;
    ((ArrayInterface *) clazz->interface)->containsObject = containsObject;
    ((ArrayInterface *) clazz->interface)->enumerateObjects = enumerateObjects;
    ((ArrayInterface *) clazz->interface)->filteredArray = filteredArray;
    ((ArrayInterface *) clazz->interface)->findObject = findObject;
    ((ArrayInterface *) clazz->interface)->firstObject = firstObject;
    ((ArrayInterface *) clazz->interface)->indexOfObject = indexOfObject;
    ((ArrayInterface *) clazz->interface)->initWithArray = initWithArray;
    ((ArrayInterface *) clazz->interface)->initWithObjects = initWithObjects;
    ((ArrayInterface *) clazz->interface)->initWithVaList = initWithVaList;
    ((ArrayInterface *) clazz->interface)->lastObject = lastObject;
    ((ArrayInterface *) clazz->interface)->mappedArray = mappedArray;
    ((ArrayInterface *) clazz->interface)->mutableCopy = mutableCopy;
    ((ArrayInterface *) clazz->interface)->objectAtIndex = objectAtIndex;
    ((ArrayInterface *) clazz->interface)->reduce = reduce;
    ((ArrayInterface *) clazz->interface)->sortedArray = sortedArray;
}

initWithArray()

static Array * initWithArray ( Array *  self, const Array *  array  )

static

Definition at line 288 of file Array.c.

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

initWithObjects()

static Array * initWithObjects ( Array *  self,   ...  )

static

Definition at line 312 of file Array.c.

                                                {
 
    va_list args;
    va_start(args, self);
 
    self = $(self, initWithVaList, args);
 
    va_end(args);
    return self;
}

initWithVaList()

static Array * initWithVaList ( Array *  self, va_list  args  )

static

Definition at line 327 of file Array.c.

                                                        {
 
    self = (Array *) super(Object, self, init);
    if (self) {
 
        ident element = va_arg(args, ident);
        while (element) {
            self->elements = realloc(self->elements, ++self->count * sizeof(ident));
            assert(self->elements);
 
            self->elements[self->count - 1] = retain(element);
            element = va_arg(args, ident);
        }
    }
 
    return self;
}

isEqual()

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

static

See also

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

Definition at line 96 of file Array.c.

                                                              {
 
    if (super(Object, self, isEqual, other)) {
        return true;
    }
 
    if (other && $(other, isKindOfClass, _Array())) {
 
        const Array *this = (Array *) self;
        const Array *that = (Array *) other;
 
        if (this->count == that->count) {
 
            for (size_t i = 0; i < this->count; i++) {
 
                const Object *thisObject = this->elements[i];
                const Object *thatObject = that->elements[i];
 
                if ($(thisObject, isEqual, thatObject) == false) {
                    return false;
                }
            }
 
            return true;
        }
    }
 
    return false;
}

lastObject()

static ident lastObject ( const Array *  self )

static

Definition at line 349 of file Array.c.

                                           {
 
    return self->count ? $(self, objectAtIndex, self->count - 1) : NULL;
}

mappedArray()

static Array * mappedArray ( const Array *  self, Functor  functor, ident  data  )

static

Definition at line 358 of file Array.c.

                                                                          {
 
    assert(functor);
 
    MutableArray *array = $$(MutableArray, arrayWithCapacity, self->count);
    assert(array);
    
    for (size_t i = 0; i < self->count; i++) {
 
        ident obj = functor(self->elements[i], data);
 
        $(array, addObject, obj);
 
        release(obj);
    }
 
    return (Array *) array;
}

mutableCopy()

static MutableArray * mutableCopy ( const Array *  self )

static

Definition at line 381 of file Array.c.

                                                    {
 
    MutableArray *copy = $(alloc(MutableArray), initWithCapacity, self->count);
    assert(copy);
 
    $(copy, addObjectsFromArray, self);
    return copy;
}

objectAtIndex()

static ident objectAtIndex ( const Array *  self, size_t  index  )

static

Definition at line 394 of file Array.c.

                                                            {
 
    assert(index < self->count);
 
    return self->elements[index];
}

reduce()

static ident reduce ( const Array *  self, Reducer  reducer, ident  accumulator, ident  data  )

static

Definition at line 405 of file Array.c.

                                                                                       {
 
    assert(reducer);
 
    for (size_t i = 0; i < self->count; i++) {
        accumulator = reducer(self->elements[i], accumulator, data);
    }
 
    return accumulator;
}

sortedArray()

static Array * sortedArray ( const Array *  self, Comparator  comparator  )

static

Definition at line 420 of file Array.c.

                                                                    {
 
    assert(comparator);
 
    MutableArray *array = $(self, mutableCopy);
 
    $(array, sort, comparator);
 
    return (Array *) array;
}