141 lines
5.4 KiB
C
141 lines
5.4 KiB
C
|
/**
|
|||
|
* \file darray.c
|
|||
|
* \brief Implémentation des fonctions pour le type \ref darray_t
|
|||
|
*/
|
|||
|
|
|||
|
#include <darray.h>
|
|||
|
#include <stdio.h>
|
|||
|
#include <string.h>
|
|||
|
|
|||
|
/// Constante pour les erreurs liées à \ref darray_t
|
|||
|
#define PTR_ERROR 2
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayNew` permet de créer un nouvel objet de type \ref darray_t ne
|
|||
|
* contenant aucun élément. Le seul paramètre, `element_size`, est utilisé afin
|
|||
|
* de connaître l’espace mémoire à allouer à chacun des éléments dans le
|
|||
|
* tableau. Cela implique qu’un objet \ref darray_t ne peut contenir que des
|
|||
|
* éléments du même type.
|
|||
|
* \param element_size Taille des objets stockés
|
|||
|
* \return Pointeur sur le nouvel objet \ref darray_t
|
|||
|
*/
|
|||
|
darray_t *darrayNew(size_t element_size) {
|
|||
|
darray_t *ret;
|
|||
|
ret = (darray_t *)malloc(sizeof(darray_t));
|
|||
|
ret->begin = NULL;
|
|||
|
ret->end = ret->begin;
|
|||
|
ret->element_size = element_size;
|
|||
|
ret->capacity = 0;
|
|||
|
return ret;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayInsert` insère l’élément `elem` avant l'élément pointé par `pos` dans
|
|||
|
* l’objet \ref darray_t. Cela décalera tous les éléments stockés dans \a `self`
|
|||
|
* pen d’un cran vers la fin du tableau et insérera à l’endroit pointé le nouvel
|
|||
|
* élément. Cette fonction modifie les membres `begin` et `end` et
|
|||
|
* potentiellement `capacity` de `self`.
|
|||
|
* \param self Objet \ref darray_t dans lequel on souhaite insérer un nouvel élément
|
|||
|
* \param pos Position à laquelle on souhaite insérer un nouvel élément
|
|||
|
* \param elem Élément que l’on souhaite insérer
|
|||
|
*/
|
|||
|
void darrayInsert(darray_t *self, void *pos, void *elem) {
|
|||
|
void *new_array;
|
|||
|
char *itr;
|
|||
|
unsigned long pos_aux;
|
|||
|
size_t size;
|
|||
|
pos_aux = (char *)pos - (char *)self->begin;
|
|||
|
if (darraySize(self) >= self->capacity) {
|
|||
|
size = darraySize(self);
|
|||
|
new_array =
|
|||
|
realloc(self->begin, (darraySize(self) + 1) * self->element_size);
|
|||
|
if (!new_array) {
|
|||
|
fprintf(stderr, "Failed memory reallocation at %s:%d\nAborting...",
|
|||
|
__FILE__, __LINE__ - 2);
|
|||
|
exit(PTR_ERROR);
|
|||
|
}
|
|||
|
self->begin = new_array;
|
|||
|
++self->capacity;
|
|||
|
self->end = (char *)self->begin + size * self->element_size;
|
|||
|
}
|
|||
|
|
|||
|
itr = (char *)self->begin + pos_aux;
|
|||
|
memmove(itr + self->element_size, itr, (char *)self->end - itr);
|
|||
|
memcpy(itr, elem, self->element_size);
|
|||
|
self->end = (char *)self->end + self->element_size;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayErase` supprime l’élément de objet \ref darray_t `self` pointé par
|
|||
|
* `pos`. Cela décalera tous les éléments suivants dans le tableau d’un cran
|
|||
|
* vers le début du tableau de manière à ce qu’il n’y aie pas d’élément vide
|
|||
|
* entre les membres `begin` et `end` de `self`. Par ailleurs, le membre `end`
|
|||
|
* de `self` se retrouve modifié par la fonction.
|
|||
|
* \param self Objet \ref `darray_t` dont on souhaite supprimer un élément
|
|||
|
* \param pos Élément de `self` que l’on souhaite supprimer
|
|||
|
*/
|
|||
|
void darrayErase(darray_t *self, void *pos) {
|
|||
|
memmove(pos, (char *)pos + self->element_size,
|
|||
|
((char *)self->end - self->element_size) - (char *)pos);
|
|||
|
self->end = (char *)self->end - self->element_size;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayPushBack` ajoute un nouvel élément `elem` à l’objet `self` à la fin du
|
|||
|
* tableau de ce dernier. Cette fonction modifie le membre `end` de `self`.
|
|||
|
* \param self Objet \ref darray_t à la fin duquel on souhaite ajouter un nouvel élément
|
|||
|
* \param elem Élément que l’on souhaite ajouter à la fin de `self`
|
|||
|
*/
|
|||
|
void darrayPushBack(darray_t *self, void *elem) {
|
|||
|
darrayInsert(self, self->end, elem);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayPopBack` permet de supprimer le dernier élément de l’objet \ref
|
|||
|
* darray_t passé en argument. Cette fonction modifie le membre `end` de ce
|
|||
|
* dernier objet.
|
|||
|
* \param self Objet dont on souhaite supprimer le dernier élément
|
|||
|
*/
|
|||
|
void darrayPopBack(darray_t *self) {
|
|||
|
darrayErase(self, (char *)self->end - self->element_size);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayDelete` supprime tous les éléments contenus par l’objet \ref darray_t
|
|||
|
* passé en argument avant de libérer la mémoire occupée par l’objet lui-même.
|
|||
|
* L’objet passé en argument ne sera plus utilisable après utilisation de cette
|
|||
|
* fonction.
|
|||
|
* \param self Objet \ref darray_t à supprimer
|
|||
|
*/
|
|||
|
void darrayDelete(darray_t *self) {
|
|||
|
free(self->begin);
|
|||
|
free(self);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darraySize` renvoie le nombre d’éléments contenu dans le \ref darray_t
|
|||
|
* `self` passé en arguments. Cette fonction ne modifie pas l’élément passé en
|
|||
|
* argument.
|
|||
|
* \param self Objet \ref darray_t dont on souhaite connaître le nombre d’éléments
|
|||
|
* \return Nombre d’éléments contenus dans `self`
|
|||
|
*/
|
|||
|
size_t darraySize(darray_t *self) {
|
|||
|
return ((char *)self->end - (char *)self->begin) / self->element_size;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* `darrayGet` permet de récupérer un élément d’un objet \ref darray_t grâce à
|
|||
|
* son index dans le tableau de l’objet `self`. Si l’index est trop grand, alors
|
|||
|
* le pointeur `NULL` sera renvoyé, sinon un pointeur de type `void*` pointant
|
|||
|
* sur l’élément correspondant sera renvoyé. Cette fonction ne modifie pas
|
|||
|
* l’objet `self`.
|
|||
|
* \param self Objet \ref darray_t duquel on souhaite obtenir un pointeur sur l’élément à l’index `idx`
|
|||
|
* \param idx Index de l’élément que l’on souhaite récupérer
|
|||
|
* \return Pointeur de type `void*` pointant sur l’élément si l’index est valide, sur NULL sinon.
|
|||
|
*/
|
|||
|
void *darrayGet(darray_t *self, size_t idx) {
|
|||
|
void *itr;
|
|||
|
itr = (char *)self->begin + idx * self->element_size;
|
|||
|
return itr;
|
|||
|
}
|