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. More...
size_t	count
	The count of elements. More...
ident	elements
	The elements. More...
Object	object
	The superclass. More...
size_t	size
	The size of each element. More...
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class. More...

Methods
Class *	_Vector (void)
	The Vector archetype. More...
void	addElement (Vector *self, const ident element)
	Adds the specified element to this Vector. More...
void	enumerateElements (const Vector *self, VectorEnumerator enumerator, ident data)
	Enumerates the elements of this Vector with the given function. More...
void	enumerateObjects (const Vector *self, VectorEnumerator enumerator, ident data)
void	filterElements (const Vector *self, Predicate predicate, ident data)
	Filters the elements of this Vector with the given Predicate. More...
void	filterElements (Vector *self, Predicate predicate, ident data)
ident	findElement (const Vector *self, Predicate predicate, ident data)
ssize_t	indexOfElement (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. More...
Vector *	initWithSize (Vector *self, size_t size)
	Initializes this Vector with the specified element size. More...
void	insertElementAtIndex (Vector *self, const ident element, size_t index)
	Inserts the element at the specified index. More...
ident	reduce (const Vector *self, Reducer reducer, ident accumulator, ident data)
void	removeAllElements (Vector *self)
	Removes all elements from this Vector without modifying its capacity. More...
void	removeElementAtIndex (Vector *self, size_t index)
	Removes the element at the specified index. More...
void	resize (Vector *self, size_t capacity)
	Resizes this Vector to the specified capacity. More...
void	sort (Vector *self, Comparator comparator)
	Sorts this Vector in place using comparator. More...
Vector *	vectorWithElements (size_t size, size_t count, ident elements)
	Creates a new Vector with the specified elements. More...
Vector *	vectorWithSize (size_t size)
	Creates a new Vector with the specified element size. More...
Methods inherited from Object
Class *	_Object (void)
	The Object archetype. More...
Object *	copy (const Object *self)
	Creates a shallow copy of this Object. More...
void	dealloc (Object *self)
	Frees all resources held by this Object. More...
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object. More...
_Bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object. More...
_Bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership. More...

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

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.

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 387 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;
}

addElement()

void addElement	(	Vector *	self,
		const ident	element
	)

Adds the specified element to this Vector.

Parameters

self	The Vector.
element	The element to add.

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

enumerateElements()

void enumerateElements	(	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 132 of file Vector.c.

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

enumerateObjects()

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

filterElements() [1/2]

void filterElements	(	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.

filterElements() [2/2]

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

Definition at line 145 of file Vector.c.

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

findElement()

ident findElement	(	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 160 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;
}

indexOfElement()

ssize_t indexOfElement	(	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 177 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 192 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 207 of file Vector.c.

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

insertElementAtIndex()

void insertElementAtIndex	(	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 221 of file Vector.c.

                                                                                  {
 
    assert(index <= self->count);
 
    $(self, addElement, 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);
}

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 238 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;
}

removeAllElements()

void removeAllElements

(

Vector *

self

)

Removes all elements from this Vector without modifying its capacity.

Parameters

self	The Vector

Definition at line 253 of file Vector.c.

                                            {
    self->count = 0;
}

removeElementAtIndex()

void removeElementAtIndex	(	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 261 of file Vector.c.

                                                             {
 
    assert(index < self->count);
 
    const size_t size = (self->count - index) * self->size;
 
    memcpy(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 276 of file Vector.c.

                                                  {
 
    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 332 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 350 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 342 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