Eina inline array usage

This example will create an inline array of chars, add some elements, print it, re-purpose the array to store ints, add some elements and print that.

We'll start with a function to compare ints we need this because the '>' operator is not a function and can't be used where Eina_Compare_Cb is needed.

int
cmp(const void *a, const void *b)
{
return *(int*)a > *(int*)b;
}

And then move on to the code we actually care about, starting with variable declarations and eina initialization:

int main(int argc, char **argv)
{
Eina_Inarray *iarr;
char ch, *ch2;
int a, *b;
struct _Eina_Inarray Eina_Inarray
Inlined array type.
Definition eina_inarray.h:191
int eina_init(void)
Initialize the Eina library.
Definition eina_main.c:244

Creating an inline array is very simple, we just need to know what type we want to store:

iarr = eina_inarray_new(sizeof(char), 0);
Eina_Inarray * eina_inarray_new(unsigned int member_size, unsigned int step)
Create new inline array.
Definition eina_inarray.c:338
Note
The second parameter(the step) is left at zero which means that eina will choose an appropriate value, this should only be changed if it's known, beforehand, how many elements the array will have.

Once we have an array we can start adding elements to it. Because the insertion function expect a memory address we have to put the value we want to store in a variable(this should be no problem since in real world usage that's usually where the value will be anyways):

ch = 'a';
eina_inarray_push(iarr, &ch);
int eina_inarray_push(Eina_Inarray *array, const void *data)
Copy the data as the last member of the array.
Definition eina_inarray.c:399
Note
Because the inline array copies the value given to it we can later change ch, which we do, without affecting the contents of the array.

So let's add some more elements:

ch = 'b';
eina_inarray_push(iarr, &ch);
ch = 'c';
eina_inarray_push(iarr, &ch);
ch = 'd';
eina_inarray_push(iarr, &ch);

We will then iterate over our array and print every position of it. The thing to note here is not so much the values which will be the expected 'a', 'b', 'c' and 'd', but rather the memory address of these values, they are sequential:

printf("Inline array of chars:\n");
printf("char: %c(pointer: %p)\n", *ch2, ch2);
#define EINA_INARRAY_FOREACH(array, itr)
walks array linearly from head to tail
Definition eina_inarray.h:676

We'll now use our array to store ints, so we need to first erase every member currently on the array:

void eina_inarray_flush(Eina_Inarray *array)
Remove every member from array.
Definition eina_inarray.c:389

And then to be able to store a different type on the same array we use the eina_inarray_step_set() function, which is just like the eina_inarray_new() function except it receives already allocated memory. This time we're going to ask eina to use a step of size 4 because that's how many elements we'll be putting on the array:

eina_inarray_step_set(iarr, sizeof(Eina_Inarray), sizeof(int), 4);
void eina_inarray_step_set(Eina_Inarray *array, unsigned int sizeof_eina_inarray, unsigned int member_size, unsigned int step)
Initialize inline array.
Definition eina_inarray.c:367
Note
Strictly speaking the reason to call eina_inarray_step_set() is not because we're storing different type, but rather because our types have different sizes. Eina inline arrays don't actually know anything about types, they only deal in blocks of memory of a given size.
Since eina_inarray_step_set() receives already allocated memory you can(and it is in fact good practice) use inline arrays not declared as pointers:
eina_inarray_step_set(&arr, sizeof(arr), sizeof(int), 4);

And now to add our integer values to the array:

a = 97;
eina_inarray_push(iarr, &a);
a = 98;
eina_inarray_push(iarr, &a);
a = 100;
eina_inarray_push(iarr, &a);

Just to change things up a bit we've left out the 99 value, but will still add it in such a way to keep the array ordered. There are many ways to do this, we could use eina_inarray_insert_at(), or we could change the value of the last member using eina_inarray_replace_at() and then append the values in the right order, but for no particular reason we're going to use eina_inarray_insert_sorted() instead:

a = 99;
int eina_inarray_insert_sorted(Eina_Inarray *array, const void *data, Eina_Compare_Cb compare)
Copy the data to array at position found by comparison function.
Definition eina_inarray.c:446

We then print the size of our array, and the array itself, much like last time the values are not surprising, and neither should it be that the memory addresses are contiguous:

printf("Inline array of integers with %d elements:\n", eina_inarray_count(iarr));
unsigned int eina_inarray_count(const Eina_Inarray *array)
number of members in array.
Definition eina_inarray.c:703
printf("int: %d(pointer: %p)\n", *b, b);

Once done we free our array and shutdown eina:

}
void eina_inarray_free(Eina_Inarray *array)
Free array and its members.
Definition eina_inarray.c:356
int eina_shutdown(void)
Shut down the Eina library.
Definition eina_main.c:315

The source for this example: eina_inarray_01.c