Objectively
Object oriented framework for C.
Loading...
Searching...
No Matches
Vector.c File Reference
#include "Config.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "Hash.h"
#include "Vector.h"

Go to the source code of this file.

Macros

#define _Class   _Vector
 
#define VECTOR_CHUNK_SIZE   64
 

Functions

static int _sort (const void *a, const void *b, void *data)
 qsort_r comparator.
 
Class * _Vector (void)
 
static void add (Vector *self, const ident element)
 
static Object * copy (const Object *self)
 
static void dealloc (Object *self)
 
static void enumerate (const Vector *self, VectorEnumerator enumerator, ident data)
 
static void filter (Vector *self, Predicate predicate, ident data)
 
static ident find (const Vector *self, Predicate predicate, ident data)
 
static int hash (const Object *self)
 
static ssize_t indexOf (const Vector *self, const ident element)
 
static void initialize (Class *clazz)
 
static Vector * initWithElements (Vector *self, size_t size, size_t count, ident elements)
 
static Vector * initWithSize (Vector *self, size_t size)
 
static void insert (Vector *self, const ident element, size_t index)
 
static bool isEqual (const Object *self, const Object *other)
 
static Vector * mappedVector (const Vector *self, Functor functor, ident data)
 
static ident reduce (const Vector *self, Reducer reducer, ident accumulator, ident data)
 
static void removeAll (Vector *self)
 
static void removeAt (Vector *self, size_t index)
 
static void removeAtFast (Vector *self, size_t index)
 
static void resize (Vector *self, size_t capacity)
 
static void sort (Vector *self, Comparator comparator)
 
static Vector * vectorWithElements (size_t size, size_t count, ident elements)
 
static Vector * vectorWithSize (size_t size)
 

Macro Definition Documentation

◆ _Class

#define _Class   _Vector

Definition at line 33 of file Vector.c.

◆ VECTOR_CHUNK_SIZE

#define VECTOR_CHUNK_SIZE   64

Definition at line 35 of file Vector.c.

Function Documentation

◆ _sort()

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

qsort_r comparator.

Definition at line 386 of file Vector.c.

386 {
387 return ((Comparator) data)(((const ident) a), ((const ident) b));
388}
static Data * data(void)
Definition Data.c:286
void * ident
The identity type, similar to Objective-C id.
Definition Types.h:49
Order(* Comparator)(const ident obj1, const ident obj2)
The Comparator function type for ordering Objects.
Definition Types.h:81

◆ _Vector()

Class * _Vector ( void  )

Definition at line 451 of file Vector.c.

451 {
452 static Class *clazz;
453 static Once once;
454
455 do_once(&once, {
456 clazz = _initialize(&(const ClassDef) {
457 .name = "Vector",
458 .superclass = _Object(),
459 .instanceSize = sizeof(Vector),
460 .interfaceSize = sizeof(VectorInterface),
461 .initialize = initialize,
462 });
463 });
464
465 return clazz;
466}
Class * _initialize(const ClassDef *def)
Initializes the given Class.
Definition Class.c:151
Class * _Object(void)
Definition Object.c:136
static void initialize(Class *clazz)
Definition Vector.c:421
long Once
The Once type.
Definition Once.h:37
#define do_once(once, block)
Executes the given block at most one time.
Definition Once.h:43
ClassDefs are passed to _initialize via an archetype to initialize a Class.
Definition Class.h:41
The runtime representation of a Class.
Definition Class.h:90
Vectors.
Definition Vector.h:51

◆ add()

static void add ( Vector *  self,
const ident  element 
)
static

Definition at line 116 of file Vector.c.

116 {
117
118 if (self->count == self->capacity) {
119
121
122 if (self->elements) {
123 self->elements = realloc(self->elements, self->capacity * self->size);
124 } else {
125 self->elements = calloc(self->capacity, self->size);
126 }
127
128 assert(self->elements);
129 }
130
131 memcpy(self->elements + self->count * self->size, element, self->size);
132 self->count++;
133}
#define VECTOR_CHUNK_SIZE
Definition Vector.c:35
size_t count
The count of elements.
Definition Vector.h:72
size_t capacity
The capacity.
Definition Vector.h:67
ident elements
The elements.
Definition Vector.h:82
size_t size
The size of each element.
Definition Vector.h:77

◆ copy()

static Object * copy ( const Object *  self)
static
See also
Object::copy(const Object *)

Definition at line 42 of file Vector.c.

42 {
43
44 const Vector *this = (Vector *) self;
45
46 Vector *that = $(alloc(Vector), initWithSize, this->size);
47
48 free(that->elements);
49 that->elements = malloc(this->capacity * this->size);
50 assert(that->elements);
51 memcpy(that->elements, this->elements, this->count * this->size);
52 that->count = this->count;
53 that->capacity = this->capacity;
54 that->destroy = this->destroy;
55
56 return (Object *) that;
57}
static void destroy(Class *clazz)
Definition Boole.c:102
#define alloc(type)
Allocate and initialize and instance of type.
Definition Class.h:226
static Vector * initWithSize(Vector *self, size_t size)
Definition Vector.c:215
Object is the root Class of The Objectively Class hierarchy.
Definition Object.h:46
Consumer destroy
Optional destructor called when an element is removed.
Definition Vector.h:90

◆ dealloc()

static void dealloc ( Object *  self)
static
See also
Object::dealloc(Object *)

Definition at line 62 of file Vector.c.

62 {
63
64 Vector *this = (Vector *) self;
65
66 $(this, removeAll);
67
68 free(this->elements);
69
70 super(Object, self, dealloc);
71}
#define super(type, obj, method,...)
static void removeAll(Vector *self)
Definition Vector.c:277
static void dealloc(Object *self)
Definition Vector.c:62

◆ enumerate()

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

Definition at line 139 of file Vector.c.

139 {
140
141 assert(enumerator);
142
143 for (size_t i = 0; i < self->count; i++) {
144 enumerator(self, self->elements + i * self->size, data);
145 }
146}

◆ filter()

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

Definition at line 152 of file Vector.c.

152 {
153
154 assert(predicate);
155
156 for (size_t i = 0; i < self->count; i++) {
157 if (!predicate(self->elements + i * self->size, data)) {
158 $(self, removeAt, i);
159 }
160 }
161}
static void removeAt(Vector *self, size_t index)
Definition Vector.c:292

◆ find()

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

Definition at line 167 of file Vector.c.

167 {
168
169 assert(predicate);
170
171 for (size_t i = 0; i < self->count; i++) {
172 if (predicate(self->elements + i * self->size, data)) {
173 return self->elements + i * self->size;
174 }
175 }
176
177 return NULL;
178}

◆ hash()

static int hash ( const Object *  self)
static
See also
Object::hash(const Object *)

Definition at line 76 of file Vector.c.

76 {
77
78 Vector *this = (Vector *) self;
79
80 const Range range = {
81 .location = 0,
82 .length = this->count * this->size
83 };
84
85 return HashForBytes(HASH_SEED, this->elements, range);
86}
int HashForBytes(int hash, const uint8_t *bytes, const Range range)
Accumulates the hash value of bytes into hash.
Definition Hash.c:28
#define HASH_SEED
The hash seed value.
Definition Hash.h:37
A location and length into contiguous collections.
Definition Types.h:54
ssize_t location
The location.
Definition Types.h:58

◆ indexOf()

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

Definition at line 184 of file Vector.c.

184 {
185
186 for (size_t i = 0; i < self->count; i++) {
187 if (memcmp(self->elements + i * self->size, element, self->size) == 0) {
188 return i;
189 }
190 }
191
192 return -1;
193}

◆ initialize()

static void initialize ( Class *  clazz)
static
See also
Class::initialize(Class *)

Definition at line 421 of file Vector.c.

421 {
422
423 ((ObjectInterface *) clazz->interface)->copy = copy;
424 ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
425 ((ObjectInterface *) clazz->interface)->hash = hash;
426 ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
427
428 ((VectorInterface *) clazz->interface)->add = add;
429 ((VectorInterface *) clazz->interface)->enumerate = enumerate;
430 ((VectorInterface *) clazz->interface)->filter = filter;
431 ((VectorInterface *) clazz->interface)->find = find;
432 ((VectorInterface *) clazz->interface)->indexOf = indexOf;
433 ((VectorInterface *) clazz->interface)->initWithElements = initWithElements;
434 ((VectorInterface *) clazz->interface)->initWithSize = initWithSize;
435 ((VectorInterface *) clazz->interface)->insert = insert;
436 ((VectorInterface *) clazz->interface)->mappedVector = mappedVector;
437 ((VectorInterface *) clazz->interface)->reduce = reduce;
438 ((VectorInterface *) clazz->interface)->removeAll = removeAll;
439 ((VectorInterface *) clazz->interface)->removeAt = removeAt;
440 ((VectorInterface *) clazz->interface)->removeAtFast = removeAtFast;
441 ((VectorInterface *) clazz->interface)->resize = resize;
442 ((VectorInterface *) clazz->interface)->sort = sort;
443 ((VectorInterface *) clazz->interface)->vectorWithElements = vectorWithElements;
444 ((VectorInterface *) clazz->interface)->vectorWithSize = vectorWithSize;
445}
static ident reduce(const Vector *self, Reducer reducer, ident accumulator, ident data)
Definition Vector.c:262
static ident find(const Vector *self, Predicate predicate, ident data)
Definition Vector.c:167
static void removeAtFast(Vector *self, size_t index)
Definition Vector.c:311
static void add(Vector *self, const ident element)
Definition Vector.c:116
static bool isEqual(const Object *self, const Object *other)
Definition Vector.c:91
static void resize(Vector *self, size_t capacity)
Definition Vector.c:332
static void filter(Vector *self, Predicate predicate, ident data)
Definition Vector.c:152
static Vector * initWithElements(Vector *self, size_t size, size_t count, ident elements)
Definition Vector.c:199
static ssize_t indexOf(const Vector *self, const ident element)
Definition Vector.c:184
static void enumerate(const Vector *self, VectorEnumerator enumerator, ident data)
Definition Vector.c:139
static Vector * vectorWithElements(size_t size, size_t count, ident elements)
Definition Vector.c:404
static Vector * vectorWithSize(size_t size)
Definition Vector.c:412
static void insert(Vector *self, const ident element, size_t index)
Definition Vector.c:229
static Vector * mappedVector(const Vector *self, Functor functor, ident data)
Definition Vector.c:246
static Object * copy(const Object *self)
Definition Vector.c:42
static void sort(Vector *self, Comparator comparator)
Definition Vector.c:394
static int hash(const Object *self)
Definition Vector.c:76
ident interface
The interface of the Class.
Definition Class.h:100
void dealloc(Object *self)
Frees all resources held by this Object.
Definition Array.c:99
ident reduce(const Vector *self, Reducer reducer, ident accumulator, ident data)
Definition Vector.c:262
Vector * vectorWithSize(size_t size)
Creates a new Vector with the specified element size.
Definition Vector.c:412
void insert(Vector *self, const ident element, size_t index)
Inserts the element at the specified index.
Definition Vector.c:229
Vector * initWithSize(Vector *self, size_t size)
Initializes this Vector with the specified element size.
Definition Vector.c:215

◆ initWithElements()

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

Definition at line 199 of file Vector.c.

199 {
200
201 self = $(self, initWithSize, size);
202 if (self) {
203 self->capacity = count;
204 self->count = count;
205 self->elements = elements;
206 }
207
208 return self;
209}

◆ initWithSize()

static Vector * initWithSize ( Vector *  self,
size_t  size 
)
static

Definition at line 215 of file Vector.c.

215 {
216
217 self = (Vector *) super(Object, self, init);
218 if (self) {
219 self->size = size;
220 assert(self->size);
221 }
222 return self;
223}
static Array * init(Array *self)
Definition Array.c:420

◆ insert()

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

Definition at line 229 of file Vector.c.

229 {
230
231 assert(index <= self->count);
232
233 $(self, add, element);
234
235 for (size_t i = self->count - 1; i > index; i--) {
236 memcpy(self->elements + i * self->size, self->elements + (i - 1) * self->size, self->size);
237 }
238
239 memcpy(self->elements + index * self->size, element, self->size);
240}

◆ isEqual()

static bool isEqual ( const Object *  self,
const Object *  other 
)
static
See also
Object::isEqual(const Object *, const Object *)

Definition at line 91 of file Vector.c.

91 {
92
93 if (super(Object, self, isEqual, other)) {
94 return true;
95 }
96
97 if (other && $(other, isKindOfClass, _Vector())) {
98
99 const Vector *this = (Vector *) self;
100 const Vector *that = (Vector *) other;
101
102 if (this->count == that->count) {
103 return memcmp(this->elements, that->elements, this->count * this->size) == 0;
104 }
105 }
106
107 return false;
108}
static bool isKindOfClass(const Object *self, const Class *clazz)
Definition Object.c:101
Class * _Vector(void)
Definition Vector.c:451

◆ mappedVector()

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

Definition at line 246 of file Vector.c.

246 {
247
248 assert(functor);
249
250 Vector *vector = $(alloc(Vector), initWithSize, self->size);
251 for (size_t i = 0; i < self->count; i++) {
252 ident result = functor(self->elements + i * self->size, data);
253 $(vector, add, result);
254 }
255 return vector;
256}

◆ reduce()

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

Definition at line 262 of file Vector.c.

262 {
263
264 assert(reducer);
265
266 for (size_t i = 0; i < self->count; i++) {
267 accumulator = reducer(self->elements + i * self->size, accumulator, data);
268 }
269
270 return accumulator;
271}

◆ removeAll()

static void removeAll ( Vector *  self)
static

Definition at line 277 of file Vector.c.

277 {
278
279 if (self->destroy) {
280 for (size_t i = 0; i < self->count; i++) {
281 self->destroy(self->elements + i * self->size);
282 }
283 }
284
285 self->count = 0;
286}

◆ removeAt()

static void removeAt ( Vector *  self,
size_t  index 
)
static

Definition at line 292 of file Vector.c.

292 {
293
294 assert(index < self->count);
295
296 if (self->destroy) {
297 self->destroy(self->elements + index * self->size);
298 }
299
300 const size_t size = (self->count - index - 1) * self->size;
301
302 memmove(self->elements + index * self->size, self->elements + (index + 1) * self->size, size);
303
304 self->count--;
305}

◆ removeAtFast()

static void removeAtFast ( Vector *  self,
size_t  index 
)
static

Definition at line 311 of file Vector.c.

311 {
312
313 assert(index < self->count);
314
315 if (self->destroy) {
316 self->destroy(self->elements + index * self->size);
317 }
318
319 const size_t last = self->count - 1;
320
321 if (index != last) {
322 memcpy(self->elements + index * self->size, self->elements + last * self->size, self->size);
323 }
324
325 self->count--;
326}

◆ resize()

static void resize ( Vector *  self,
size_t  capacity 
)
static

Definition at line 332 of file Vector.c.

332 {
333
334 if (self->destroy) {
335 for (size_t i = capacity; i < self->count; i++) {
336 self->destroy(self->elements + i * self->size);
337 }
338 }
339
340 self->elements = realloc(self->elements, capacity * self->size);
341 assert(self->elements);
342
343 self->capacity = capacity;
344 self->count = min(self->count, self->capacity);
345}
#define min(a, b)
Definition Types.h:158

◆ sort()

static void sort ( Vector *  self,
Comparator  comparator 
)
static

Definition at line 394 of file Vector.c.

394 {
395 qsort_r(self->elements, self->count, self->size, _sort, comparator);
396}
static int _sort(const void *a, const void *b, void *data)
qsort_r comparator.
Definition Vector.c:386

◆ vectorWithElements()

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

Definition at line 404 of file Vector.c.

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

◆ vectorWithSize()

static Vector * vectorWithSize ( size_t  size)
static

Definition at line 412 of file Vector.c.

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