MutableArray.c File Reference

#include "Config.h"
#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include "MutableArray.h"

Go to the source code of this file.

Macros
#define	_Class   _MutableArray
#define	ARRAY_CHUNK_SIZE   64

Functions
Class *	_MutableArray (void)
static int	_quicksort (const void *a, const void *b, void *data)
	GNU qsort_r. More...
static void	addObject (MutableArray *self, const ident obj)
static void	addObjects (MutableArray *self, const ident obj,...)
static void	addObjectsFromArray (MutableArray *self, const Array *array)
static MutableArray *	array (void)
static MutableArray *	arrayWithCapacity (size_t capacity)
static Object *	copy (const Object *self)
static void	filter (MutableArray *self, Predicate predicate, ident data)
static MutableArray *	init (MutableArray *self)
static void	initialize (Class *clazz)
static MutableArray *	initWithCapacity (MutableArray *self, size_t capacity)
static void	insertObjectAtIndex (MutableArray *self, ident obj, size_t index)
void	quicksort (ident base, size_t count, size_t size, Comparator comparator, ident data)
	A portability wrapper around reentrant qsort. More...
static void	removeAllObjects (MutableArray *self)
static void	removeAllObjectsWithEnumerator (MutableArray *self, ArrayEnumerator enumerator, ident data)
static void	removeLastObject (MutableArray *self)
static void	removeObject (MutableArray *self, const ident obj)
static void	removeObjectAtIndex (MutableArray *self, size_t index)
static void	setObjectAtIndex (MutableArray *self, const ident obj, size_t index)
static void	sort (MutableArray *self, Comparator comparator)

Macro Definition Documentation

_Class

#define _Class   _MutableArray

Definition at line 73 of file MutableArray.c.

ARRAY_CHUNK_SIZE

#define ARRAY_CHUNK_SIZE   64

Definition at line 75 of file MutableArray.c.

Function Documentation

_MutableArray()

Class * _MutableArray

(

void

)

Definition at line 349 of file MutableArray.c.

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

_quicksort()

static int _quicksort ( const void *  a, const void *  b, void *  data  )

static

GNU qsort_r.

Definition at line 63 of file MutableArray.c.

                                                                {
    return ((Comparator) data)(*((const ident *) a), *((const ident *) b));
}

addObject()

static void addObject ( MutableArray *  self, const ident  obj  )

static

Definition at line 99 of file MutableArray.c.

                                                           {
 
    Array *array = (Array *) self;
    if (array->count == self->capacity) {
 
        self->capacity += ARRAY_CHUNK_SIZE;
 
        if (array->elements) {
            array->elements = realloc(array->elements, self->capacity * sizeof(ident));
        } else {
            array->elements = calloc(self->capacity, sizeof(ident));
        }
 
        assert(array->elements);
    }
 
    array->elements[array->count++] = retain(obj);
}

addObjects()

static void addObjects ( MutableArray *  self, const ident  obj,   ...  )

static

Definition at line 122 of file MutableArray.c.

                                                                 {
 
    va_list args;
    va_start(args, obj);
 
    ident object = obj;
    while (object) {
        $(self, addObject, object);
        object = va_arg(args, ident);
    }
 
    va_end(args);
}

addObjectsFromArray()

static void addObjectsFromArray ( MutableArray *  self, const Array *  array  )

static

Definition at line 140 of file MutableArray.c.

                                                                        {
 
    if (array) {
        for (size_t i = 0; i < array->count; i++) {
            $(self, addObject, array->elements[i]);
        }
    }
}

array()

static MutableArray * array ( void  )

static

Definition at line 153 of file MutableArray.c.

                                 {
 
    return $(alloc(MutableArray), init);
}

arrayWithCapacity()

static MutableArray * arrayWithCapacity ( size_t  capacity )

static

Definition at line 162 of file MutableArray.c.

                                                        {
 
    return $(alloc(MutableArray), initWithCapacity, capacity);
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 82 of file MutableArray.c.

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

filter()

static void filter ( MutableArray *  self, Predicate  predicate, ident  data  )

static

Definition at line 171 of file MutableArray.c.

                                                                        {
 
    assert(predicate);
 
    for (size_t i = 0; i < self->array.count; i++) {
        if (predicate(self->array.elements[i], data) == false) {
            $(self, removeObjectAtIndex, i--);
        }
    }
}

init()

static MutableArray * init ( MutableArray *  self )

static

Definition at line 186 of file MutableArray.c.

                                              {
 
    return $(self, initWithCapacity, 0);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 323 of file MutableArray.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->copy = copy;
 
    ((MutableArrayInterface *) clazz->interface)->addObject = addObject;
    ((MutableArrayInterface *) clazz->interface)->addObjects = addObjects;
    ((MutableArrayInterface *) clazz->interface)->addObjectsFromArray = addObjectsFromArray;
    ((MutableArrayInterface *) clazz->interface)->array = array;
    ((MutableArrayInterface *) clazz->interface)->arrayWithCapacity = arrayWithCapacity;
    ((MutableArrayInterface *) clazz->interface)->filter = filter;
    ((MutableArrayInterface *) clazz->interface)->init = init;
    ((MutableArrayInterface *) clazz->interface)->initWithCapacity = initWithCapacity;
    ((MutableArrayInterface *) clazz->interface)->insertObjectAtIndex = insertObjectAtIndex;
    ((MutableArrayInterface *) clazz->interface)->removeAllObjects = removeAllObjects;
    ((MutableArrayInterface *) clazz->interface)->removeAllObjectsWithEnumerator = removeAllObjectsWithEnumerator;
    ((MutableArrayInterface *) clazz->interface)->removeLastObject = removeLastObject;
    ((MutableArrayInterface *) clazz->interface)->removeObject = removeObject;
    ((MutableArrayInterface *) clazz->interface)->removeObjectAtIndex = removeObjectAtIndex;
    ((MutableArrayInterface *) clazz->interface)->setObjectAtIndex = setObjectAtIndex;
    ((MutableArrayInterface *) clazz->interface)->sort = sort;
}

initWithCapacity()

static MutableArray * initWithCapacity ( MutableArray *  self, size_t  capacity  )

static

Definition at line 195 of file MutableArray.c.

                                                                           {
 
    self = (MutableArray *) super(Object, self, init);
    if (self) {
 
        self->capacity = capacity;
        if (self->capacity) {
 
            self->array.elements = calloc(self->capacity, sizeof(ident));
            assert(self->array.elements);
        }
    }
 
    return self;
}

insertObjectAtIndex()

static void insertObjectAtIndex ( MutableArray *  self, ident  obj, size_t  index  )

static

Definition at line 215 of file MutableArray.c.

                                                                             {
 
    assert(index <= self->array.count);
 
    $(self, addObject, obj);
 
    for (size_t i = self->array.count - 1; i > index; i--) {
        self->array.elements[i] = self->array.elements[i - 1];
    }
 
    self->array.elements[index] = obj;
}

quicksort()

void quicksort	(	ident	base,
		size_t	count,
		size_t	size,
		Comparator	comparator,
		ident	data
	)

A portability wrapper around reentrant qsort.

Parameters

base	The base of the array to sort.
count	The count of elements in the array
size	The size of each element in the array.
comparator	The Comparator to sort with.
data	User data.

Definition at line 67 of file MutableArray.c.

                                                                                         {
    qsort_r(base, count, size, _quicksort, comparator);
}

removeAllObjects()

static void removeAllObjects ( MutableArray *  self )

static

Definition at line 232 of file MutableArray.c.

                                                 {
 
    while (self->array.count) {
        $(self, removeLastObject);
    }
}

removeAllObjectsWithEnumerator()

static void removeAllObjectsWithEnumerator ( MutableArray *  self, ArrayEnumerator  enumerator, ident  data  )

static

Definition at line 243 of file MutableArray.c.

                                                                                                       {
 
    assert(enumerator);
 
    while (self->array.count) {
 
        enumerator((Array *) self, $((Array *) self, lastObject), data);
 
        $(self, removeLastObject);
    }
}

removeLastObject()

static void removeLastObject ( MutableArray *  self )

static

Definition at line 259 of file MutableArray.c.

                                                 {
 
    if (self->array.count) {
        $(self, removeObjectAtIndex, self->array.count - 1);
    }
}

removeObject()

static void removeObject ( MutableArray *  self, const ident  obj  )

static

Definition at line 270 of file MutableArray.c.

                                                              {
 
    const ssize_t index = $((Array *) self, indexOfObject, obj);
    if (index > -1) {
        $(self, removeObjectAtIndex, index);
    }
}

removeObjectAtIndex()

static void removeObjectAtIndex ( MutableArray *  self, size_t  index  )

static

Definition at line 282 of file MutableArray.c.

                                                                  {
 
    assert(index < self->array.count);
 
    release(self->array.elements[index]);
 
    for (size_t i = index; i < self->array.count - 1; i++) {
        self->array.elements[i] = self->array.elements[i + 1];
    }
 
    self->array.count--;
}

setObjectAtIndex()

static void setObjectAtIndex ( MutableArray *  self, const ident  obj, size_t  index  )

static

Definition at line 299 of file MutableArray.c.

                                                                                {
 
    assert(index < self->array.count);
 
    retain(obj);
 
    release(self->array.elements[index]);
 
    self->array.elements[index] = obj;
}

sort()

static void sort ( MutableArray *  self, Comparator  comparator  )

static

Definition at line 314 of file MutableArray.c.

                                                            {
    quicksort(self->array.elements, self->array.count, sizeof(ident), comparator, NULL);
}