Vector Struct Reference

#include <Vector.h>

Overview

Vectors.

Definition at line 51 of file Vector.h.

Inheritance diagram for Vector:

Properties
size_t	capacity
	The capacity.
size_t	count
	The count of elements.
Consumer	destroy
	Optional destructor called when an element is removed.
ident	elements
	The elements.
Object	object
	The superclass.
size_t	size
	The size of each element.
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class.
unsigned int	magic
	A header to allow introspection of Object types.

Methods
Class *	_Vector (void)
	The Vector archetype.
void	add (Vector *self, const ident element)
	Adds the specified element to this Vector.
void	enumerate (const Vector *self, VectorEnumerator enumerator, ident data)
	Enumerates the elements of this Vector with the given function.
void	filter (const Vector *self, Predicate predicate, ident data)
	Filters the elements of this Vector with the given Predicate.
void	filter (Vector *self, Predicate predicate, ident data)
ident	find (const Vector *self, Predicate predicate, ident data)
ssize_t	indexOf (const Vector *self, const ident element)
Vector *	initWithElements (Vector *self, size_t size, size_t count, ident elements)
	Initializes this Vector with the specified elements.
Vector *	initWithSize (Vector *self, size_t size)
	Initializes this Vector with the specified element size.
void	insert (Vector *self, const ident element, size_t index)
	Inserts the element at the specified index.
Vector *	mappedVector (const Vector *self, Functor functor, ident data)
	Returns a new Vector containing the elements of this Vector transformed by functor.
ident	reduce (const Vector *self, Reducer reducer, ident accumulator, ident data)
void	removeAll (Vector *self)
	Removes all elements from this Vector without modifying its capacity.
void	removeAt (Vector *self, size_t index)
	Removes the element at the specified index.
void	resize (Vector *self, size_t capacity)
	Resizes this Vector to the specified capacity.
void	sort (Vector *self, Comparator comparator)
	Sorts this Vector in place using comparator.
Vector *	vectorWithElements (size_t size, size_t count, ident elements)
	Creates a new Vector with the specified elements.
Vector *	vectorWithSize (size_t size)
	Creates a new Vector with the specified element size.
Methods inherited from Object
Class *	_Object (void)
	The Object archetype.
Object *	copy (const Object *self)
	Creates a shallow copy of this Object.
void	dealloc (Object *self)
	Frees all resources held by this Object.
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object.
bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object.
bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership.

Protected Attributes
VectorInterface *	interface
	The interface.
Protected Attributes inherited from Object
ObjectInterface *	interface
	The interface.

Property Details

capacity

size_t Vector::capacity

The capacity.

Definition at line 67 of file Vector.h.

count

size_t Vector::count

The count of elements.

Definition at line 72 of file Vector.h.

destroy

Consumer Vector::destroy

Optional destructor called when an element is removed.

The argument is a pointer into the Vector's contiguous element storage, not an owned object pointer. Cast it to the appropriate element pointer type to access the value being destroyed.

Definition at line 90 of file Vector.h.

elements

ident Vector::elements

The elements.

Definition at line 82 of file Vector.h.

interface

VectorInterface* Vector::interface

protected

The interface.

Definition at line 62 of file Vector.h.

object

Object Vector::object

The superclass.

Definition at line 56 of file Vector.h.

size

size_t Vector::size

The size of each element.

Definition at line 77 of file Vector.h.

Method Details

_Vector()

Class * _Vector

(

void

)

The Vector archetype.

Returns

The Vector Class.

Definition at line 428 of file Vector.c.

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

add()

void add	(	Vector *	self,
		const ident	element
	)

Adds the specified element to this Vector.

Parameters

self	The Vector.
element	The element to add.

Definition at line 116 of file Vector.c.

                                                   {
 
  if (self->count == self->capacity) {
 
    self->capacity += VECTOR_CHUNK_SIZE;
 
    if (self->elements) {
      self->elements = realloc(self->elements, self->capacity * self->size);
    } else {
      self->elements = calloc(self->capacity, self->size);
    }
 
    assert(self->elements);
  }
 
  memcpy(self->elements + self->count * self->size, element, self->size);
  self->count++;
}

enumerate()

void enumerate	(	const Vector *	self,
		VectorEnumerator	enumerator,
		ident	data
	)

Enumerates the elements of this Vector with the given function.

Parameters

self	The Vector.
enumerator	The enumerator function.
data	User data.

Definition at line 139 of file Vector.c.

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

filter() [1/2]

void filter	(	const Vector *	self,
		Predicate	predicate,
		ident	data
	)

Filters the elements of this Vector with the given Predicate.

Parameters

self	The Vector.
predicate	The Predicate.
data	User data.

filter() [2/2]

void filter	(	Vector *	self,
		Predicate	predicate,
		ident	data
	)

Definition at line 152 of file Vector.c.

                                                                  {
 
  assert(predicate);
 
  for (size_t i = 0; i < self->count; i++) {
    if (!predicate(self->elements + i * self->size, data)) {
      $(self, removeAt, i);
    }
  }
}

find()

ident find	(	const Vector *	self,
		Predicate	predicate,
		ident	data
	)

Parameters

self	The Vector.
predicate	The Predicate.
data	User data.

Returns

The first element of this Vector to pass the given Predicate.

Definition at line 167 of file Vector.c.

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

indexOf()

ssize_t indexOf	(	const Vector *	self,
		const ident	element
	)

Parameters

self	The Vector.
element	The element.

Returns

The index of the given element, or -1 if not found.

Definition at line 184 of file Vector.c.

                                                                {
 
  for (size_t i = 0; i < self->count; i++) {
    if (memcmp(self->elements + i * self->size, element, self->size) == 0) {
      return i;
    }
  }
 
  return -1;
}

initWithElements()

Vector * initWithElements	(	Vector *	self,
		size_t	size,
		size_t	count,
		ident	elements
	)

Initializes this Vector with the specified elements.

Parameters

self	The Vector.
size	The element size.
count	The count of elements.
elements	The elements, which will be freed when this Vector is released.

Returns

The initialized Vector, or NULL on error.

Definition at line 199 of file Vector.c.

                                                                                         {
 
  self = $(self, initWithSize, size);
  if (self) {
    self->count = count;
    self->elements = elements;
  }
 
  return self;
}

initWithSize()

Vector * initWithSize	(	Vector *	self,
		size_t	size
	)

Initializes this Vector with the specified element size.

Parameters

self	The Vector.
size	The element size.

Returns

The initialized Vector, or NULL on error.

Definition at line 214 of file Vector.c.

                                                       {
 
  self = (Vector *) super(Object, self, init);
  if (self) {
    self->size = size;
    assert(self->size);
  }
  return self;
}

insert()

void insert	(	Vector *	self,
		const ident	element,
		size_t	index
	)

Inserts the element at the specified index.

Parameters

self	The Vector.
element	The element to insert.
index	The index at which to insert.

Definition at line 228 of file Vector.c.

                                                                    {
 
  assert(index <= self->count);
 
  $(self, add, element);
 
  for (size_t i = self->count - 1; i > index; i--) {
    memcpy(self->elements + i * self->size, self->elements + (i - 1) * self->size, self->size);
  }
 
  memcpy(self->elements + index * self->size, element, self->size);
}

mappedVector()

Vector * mappedVector	(	const Vector *	self,
		Functor	functor,
		ident	data
	)

Returns a new Vector containing the elements of this Vector transformed by functor.

Parameters

self	The Vector.
functor	The Functor.
data	User data.

Returns

A new mapped Vector.

Definition at line 245 of file Vector.c.

                                                                             {
 
  assert(functor);
 
  Vector *vector = $(alloc(Vector), initWithSize, self->size);
  for (size_t i = 0; i < self->count; i++) {
    ident result = functor(self->elements + i * self->size, data);
    $(vector, add, result);
  }
  return vector;
}

reduce()

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

Parameters

self	The Vector.
reducer	The Reducer.
accumulator	The initial accumulator value.
data	User data.

Returns

The reduction result.

Definition at line 261 of file Vector.c.

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

removeAll()

void removeAll

(

Vector *

self

)

Removes all elements from this Vector without modifying its capacity.

Parameters

self	The Vector

Definition at line 276 of file Vector.c.

                                    {
 
  if (self->destroy) {
    for (size_t i = 0; i < self->count; i++) {
      self->destroy(self->elements + i * self->size);
    }
  }
 
  self->count = 0;
}

removeAt()

void removeAt	(	Vector *	self,
		size_t	index
	)

Removes the element at the specified index.

Parameters

self	The Vector.
index	The index of the element to remove.

Definition at line 291 of file Vector.c.

                                                 {
 
  assert(index < self->count);
 
  if (self->destroy) {
    self->destroy(self->elements + index * self->size);
  }
 
  const size_t size = (self->count - index - 1) * self->size;
 
  memmove(self->elements + index * self->size, self->elements + (index + 1) * self->size, size);
 
  self->count--;
}

resize()

void resize	(	Vector *	self,
		size_t	capacity
	)

Resizes this Vector to the specified capacity.

Parameters

self	The Vector.
capacity	The desired capacity.

Definition at line 310 of file Vector.c.

                                                  {
 
  if (self->destroy) {
    for (size_t i = capacity; i < self->count; i++) {
      self->destroy(self->elements + i * self->size);
    }
  }
 
  self->elements = realloc(self->elements, capacity * self->size);
  assert(self->elements);
 
  self->capacity = capacity;
  self->count = min(self->count, self->capacity);
}

sort()

void sort	(	Vector *	self,
		Comparator	comparator
	)

Sorts this Vector in place using comparator.

Parameters

self	The Vector.
comparator	A Comparator.

Definition at line 372 of file Vector.c.

                                                      {
  qsort_r(self->elements, self->count, self->size, _sort, comparator);
}

vectorWithElements()

Vector * vectorWithElements	(	size_t	size,
		size_t	count,
		ident	elements
	)

Creates a new Vector with the specified elements.

Parameters

size	The element size.
count	The count of elements.
elements	THe elements, which will be freed when this Vector is released.

Returns

The new Vector.

Definition at line 382 of file Vector.c.

                                                                             {
  return $(alloc(Vector), initWithElements, size, count, elements);
}

vectorWithSize()

Vector * vectorWithSize

(

size_t

size

)

Creates a new Vector with the specified element size.

Parameters

size	The element size.

Returns

The new Vector.

Definition at line 390 of file Vector.c.

                                           {
  return $(alloc(Vector), initWithSize, size);
}

---

The documentation for this struct was generated from the following files:

• Sources/Objectively/Vector.h
• Sources/Objectively/Vector.c