Tizen Native API  6.0
Eina inline array usage

This example creates an inline array of chars, adds some elements, prints them, re-purposes the array to store ints, adds some elements and prints that.

We are going to 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.

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 EINA_UNUSED, char **argv EINA_UNUSED)
   Eina_Inarray *iarr;
   char ch, *ch2;
   int a, *b;


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);

The second parameter(the step) is left at zero which means that eina chooses an appropriate value, this should only be changed if it's known, beforehand, that how many elements the array has.

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

   ch = 'a';
   eina_inarray_push(iarr, &ch);

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 then iterate over our array and print every position of it. The thing to note here is not so much the values, which are 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);

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

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 an 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 are going to put in the array:

   eina_inarray_step_set(iarr, sizeof(Eina_Inarray), sizeof(int), 4);

Strictly speaking the reason to call eina_inarray_step_set() is not because we're storing a different type, but because our types have different sizes. Eina inline arrays don't actually know anything about types, they only deal with blocks of memory of a given size.
Since eina_inarray_step_set() receives already allocated memory, you can (and it is in fact a good practice) use inline arrays that are not declared as pointers:
 Eina_Inarray arr;
 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 we still add it in such a way that it keeps 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;
   eina_inarray_insert_sorted(iarr, &a, cmp);

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));
     printf("int: %d(pointer: %p)\n", *b, b);

Once done we free our array and shutdown eina:

The source for this example: eina_inarray_01.c