Array.c File Reference

#include "Config.h"
#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include "Array.h"
#include "Hash.h"
#include "String.h"

Go to the source code of this file.

Macros
#define	_Class   _Array
#define	ARRAY_CHUNK_SIZE   64

Functions
Class *	_Array (void)
static int	_quicksort (const void *a, const void *b, void *data)
	GNU qsort_r.
static void	addObject (Array *self, const ident obj)
static void	addObjects (Array *self, const ident obj,...)
static void	addObjectsFromArray (Array *self, const Array *array)
static Array *	array (void)
static Array *	arrayWithArray (const Array *array)
static Array *	arrayWithCapacity (size_t capacity)
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	enumerate (const Array *self, ArrayEnumerator enumerator, ident data)
static void	filter (Array *self, Predicate predicate, ident data)
static Array *	filteredArray (const Array *self, Predicate predicate, ident data)
static ident	find (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 Array *	init (Array *self)
static void	initialize (Class *clazz)
static Array *	initWithArray (Array *self, const Array *array)
static Array *	initWithCapacity (Array *self, size_t capacity)
static Array *	initWithObjects (Array *self,...)
static Array *	initWithVaList (Array *self, va_list args)
static void	insertObjectAtIndex (Array *self, ident obj, size_t index)
static bool	isEqual (const Object *self, const Object *other)
static ident	lastObject (const Array *self)
static void	map (Array *self, Functor functor, ident data)
static Array *	mappedArray (const Array *self, Functor functor, ident data)
static ident	objectAtIndex (const Array *self, size_t index)
void	quicksort (ident base, size_t count, size_t size, Comparator comparator, ident data)
	A portability wrapper around reentrant qsort.
static ident	reduce (const Array *self, Reducer reducer, ident accumulator, ident data)
static void	removeAllObjects (Array *self)
static void	removeAllObjectsWithEnumerator (Array *self, ArrayEnumerator enumerator, ident data)
static void	removeLastObject (Array *self)
static void	removeObject (Array *self, const ident obj)
static void	removeObjectAtIndex (Array *self, size_t index)
static void	setObjectAtIndex (Array *self, const ident obj, size_t index)
static void	sort (Array *self, Comparator comparator)
static Array *	sortedArray (const Array *self, Comparator comparator)

Macro Definition Documentation

_Class

#define _Class   _Array

Definition at line 75 of file Array.c.

ARRAY_CHUNK_SIZE

#define ARRAY_CHUNK_SIZE   64

Definition at line 77 of file Array.c.

Function Documentation

_Array()

Class * _Array

(

void

)

Definition at line 760 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;
}

_quicksort()

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

static

GNU qsort_r.

Definition at line 65 of file Array.c.

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

addObject()

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

static

Definition at line 181 of file Array.c.

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

addObjects()

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

static

Definition at line 203 of file Array.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 ( Array *  self, const Array *  array  )

static

Definition at line 221 of file Array.c.

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

array()

static Array * array ( void  )

static

Definition at line 234 of file Array.c.

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

arrayWithArray()

static Array * arrayWithArray ( const Array *  array )

static

Definition at line 243 of file Array.c.

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

arrayWithCapacity()

static Array * arrayWithCapacity ( size_t  capacity )

static

Definition at line 252 of file Array.c.

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

arrayWithObjects()

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

static

Definition at line 261 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 286 of file Array.c.

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

componentsJoinedByCharacters()

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

static

Definition at line 295 of file Array.c.

                                                                                  {
 
  String *string = $(alloc(String), 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 318 of file Array.c.

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

containsObject()

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

static

Definition at line 326 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 84 of file Array.c.

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

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 99 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 115 of file Array.c.

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

enumerate()

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

static

Definition at line 334 of file Array.c.

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

filter()

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

static

Definition at line 347 of file Array.c.

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

filteredArray()

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

static

Definition at line 362 of file Array.c.

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

find()

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

static

Definition at line 377 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 394 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 129 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 403 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;
}

init()

static Array * init ( Array *  self )

static

Definition at line 420 of file Array.c.

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

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 710 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)->addObject = addObject;
  ((ArrayInterface *) clazz->interface)->addObjects = addObjects;
  ((ArrayInterface *) clazz->interface)->addObjectsFromArray = addObjectsFromArray;
  ((ArrayInterface *) clazz->interface)->array = array;
  ((ArrayInterface *) clazz->interface)->arrayWithArray = arrayWithArray;
  ((ArrayInterface *) clazz->interface)->arrayWithCapacity = arrayWithCapacity;
  ((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)->enumerate = enumerate;
  ((ArrayInterface *) clazz->interface)->filter = filter;
  ((ArrayInterface *) clazz->interface)->filteredArray = filteredArray;
  ((ArrayInterface *) clazz->interface)->find = find;
  ((ArrayInterface *) clazz->interface)->firstObject = firstObject;
  ((ArrayInterface *) clazz->interface)->indexOfObject = indexOfObject;
  ((ArrayInterface *) clazz->interface)->init = init;
  ((ArrayInterface *) clazz->interface)->initWithArray = initWithArray;
  ((ArrayInterface *) clazz->interface)->initWithCapacity = initWithCapacity;
  ((ArrayInterface *) clazz->interface)->initWithObjects = initWithObjects;
  ((ArrayInterface *) clazz->interface)->initWithVaList = initWithVaList;
  ((ArrayInterface *) clazz->interface)->insertObjectAtIndex = insertObjectAtIndex;
  ((ArrayInterface *) clazz->interface)->lastObject = lastObject;
  ((ArrayInterface *) clazz->interface)->map = map;
  ((ArrayInterface *) clazz->interface)->mappedArray = mappedArray;
  ((ArrayInterface *) clazz->interface)->objectAtIndex = objectAtIndex;
  ((ArrayInterface *) clazz->interface)->reduce = reduce;
  ((ArrayInterface *) clazz->interface)->removeAllObjects = removeAllObjects;
  ((ArrayInterface *) clazz->interface)->removeAllObjectsWithEnumerator = removeAllObjectsWithEnumerator;
  ((ArrayInterface *) clazz->interface)->removeLastObject = removeLastObject;
  ((ArrayInterface *) clazz->interface)->removeObject = removeObject;
  ((ArrayInterface *) clazz->interface)->removeObjectAtIndex = removeObjectAtIndex;
  ((ArrayInterface *) clazz->interface)->setObjectAtIndex = setObjectAtIndex;
  ((ArrayInterface *) clazz->interface)->sort = sort;
  ((ArrayInterface *) clazz->interface)->sortedArray = sortedArray;
}

initWithArray()

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

static

Definition at line 429 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;
}

initWithCapacity()

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

static

Definition at line 453 of file Array.c.

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

initWithObjects()

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

static

Definition at line 473 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 488 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;
}

insertObjectAtIndex()

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

static

Definition at line 510 of file Array.c.

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

isEqual()

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

static

See also

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

Definition at line 145 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 527 of file Array.c.

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

map()

static void map ( Array *  self, Functor  functor, ident  data  )

static

Definition at line 536 of file Array.c.

                                                          {
 
  assert(functor);
 
  for (size_t i = 0; i < self->count; i++) {
    ident obj = functor(self->elements[i], data);
 
    retain(obj);
 
    release(self->elements[i]);
 
    self->elements[i] = obj;
  }
}

mappedArray()

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

static

Definition at line 555 of file Array.c.

                                                                          {
 
  assert(functor);
 
  Array *array = $(alloc(Array), initWithCapacity, 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;
}

objectAtIndex()

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

static

Definition at line 578 of file Array.c.

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

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 69 of file Array.c.

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

reduce()

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

static

Definition at line 589 of file Array.c.

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

removeAllObjects()

static void removeAllObjects ( Array *  self )

static

Definition at line 604 of file Array.c.

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

removeAllObjectsWithEnumerator()

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

static

Definition at line 615 of file Array.c.

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

removeLastObject()

static void removeLastObject ( Array *  self )

static

Definition at line 631 of file Array.c.

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

removeObject()

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

static

Definition at line 642 of file Array.c.

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

removeObjectAtIndex()

static void removeObjectAtIndex ( Array *  self, size_t  index  )

static

Definition at line 654 of file Array.c.

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

setObjectAtIndex()

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

static

Definition at line 671 of file Array.c.

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

sort()

static void sort ( Array *  self, Comparator  comparator  )

static

Definition at line 686 of file Array.c.

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

sortedArray()

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

static

Definition at line 694 of file Array.c.

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