

This example creates an inline array of chars, adds some elements, prints them, re-\/purposes the array to store ints, adds some elements and print 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. 
\begin{DoxyCodeInclude}
\textcolor{keywordtype}{int}
cmp(\textcolor{keyword}{const} \textcolor{keywordtype}{void} *a, \textcolor{keyword}{const} \textcolor{keywordtype}{void} *b)
\{
   \textcolor{keywordflow}{return} *(\textcolor{keywordtype}{int}*)a > *(\textcolor{keywordtype}{int}*)b;
\}

\end{DoxyCodeInclude}


And then move on to the code we actually care about, starting with variable declarations and eina initialization\+: 
\begin{DoxyCodeInclude}

\textcolor{keywordtype}{int} main(\textcolor{keywordtype}{int} argc EINA\_UNUSED, \textcolor{keywordtype}{char} **argv EINA\_UNUSED)
\{
   \hyperlink{struct__Eina__Inarray}{Eina\_Inarray} *iarr;
   \textcolor{keywordtype}{char} ch, *ch2;
   \textcolor{keywordtype}{int} a, *b;

   \hyperlink{group__Eina__Main__Group_gabf448ada5bc81a07342b66c6f818ee5e}{eina\_init}();

\end{DoxyCodeInclude}


Creating an inline array is very simple, we just need to know what type we want to store\+: 
\begin{DoxyCodeInclude}
   iarr = \hyperlink{group__Eina__Inline__Array__Group_ga38a116a1355055b470c31bb4f633e53b}{eina\_inarray\_new}(\textcolor{keyword}{sizeof}(\textcolor{keywordtype}{char}), 0);

\end{DoxyCodeInclude}
 \begin{DoxyNote}{Note}
The second parameter(the step) is left at zero which means that eina chooses an appropriate value, this should {\bfseries only} be changed if it's known, beforehand, that how many elements the array has.
\end{DoxyNote}
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)\+: 
\begin{DoxyCodeInclude}

   ch = \textcolor{charliteral}{'a'};
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &ch);

\end{DoxyCodeInclude}
 \begin{DoxyNote}{Note}
Because the inline array copies the value given to it we can later change {\ttfamily ch}, which we do, without affecting the contents of the array.
\end{DoxyNote}
So let's add some more elements\+: 
\begin{DoxyCodeInclude}
   ch = \textcolor{charliteral}{'b'};
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &ch);
   ch = \textcolor{charliteral}{'c'};
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &ch);
   ch = \textcolor{charliteral}{'d'};
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &ch);

\end{DoxyCodeInclude}


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\+: 
\begin{DoxyCodeInclude}

   printf(\textcolor{stringliteral}{"Inline array of chars:\(\backslash\)n"});
   \hyperlink{group__Eina__Inline__Array__Group_gab6ffcad27b5099aa34af9ecd5e2b22f9}{EINA\_INARRAY\_FOREACH}(iarr, ch2)
     printf("\textcolor{keywordtype}{char}: %c(pointer: %p)\(\backslash\)n", *ch2, ch2);

\end{DoxyCodeInclude}


We are now going to use our array to store ints, so we need to first erase every member currently on the array\+: 
\begin{DoxyCodeInclude}

   \hyperlink{group__Eina__Inline__Array__Group_ga4e2b2a5b7d01613db5b578d8dbec36b7}{eina\_inarray\_flush}(iarr);

\end{DoxyCodeInclude}


And then to be able to store a different type on the same array, we use the \hyperlink{group__Eina__Inline__Array__Group_ga97ceb13e335d8b8aae8dfcce735ec274}{eina\+\_\+inarray\+\_\+step\+\_\+set()} function, which is just like the \hyperlink{group__Eina__Inline__Array__Group_ga38a116a1355055b470c31bb4f633e53b}{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\+: 
\begin{DoxyCodeInclude}
   \hyperlink{group__Eina__Inline__Array__Group_ga97ceb13e335d8b8aae8dfcce735ec274}{eina\_inarray\_step\_set}(iarr, \textcolor{keyword}{sizeof}(\hyperlink{struct__Eina__Inarray}{Eina\_Inarray}), \textcolor{keyword}{sizeof}(\textcolor{keywordtype}{int}), 4);

\end{DoxyCodeInclude}
 \begin{DoxyNote}{Note}
Strictly speaking the reason to call \hyperlink{group__Eina__Inline__Array__Group_ga97ceb13e335d8b8aae8dfcce735ec274}{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 \hyperlink{group__Eina__Inline__Array__Group_ga97ceb13e335d8b8aae8dfcce735ec274}{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\+: 
\begin{DoxyCode}
\hyperlink{struct__Eina__Inarray}{Eina\_Inarray} arr;
\hyperlink{group__Eina__Inline__Array__Group_ga97ceb13e335d8b8aae8dfcce735ec274}{eina\_inarray\_step\_set}(&arr, \textcolor{keyword}{sizeof}(arr), \textcolor{keyword}{sizeof}(\textcolor{keywordtype}{int}), 4);
\end{DoxyCode}

\end{DoxyNote}
And now to add our integer values to the array\+: 
\begin{DoxyCodeInclude}

   a = 97;
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &a);
   a = 98;
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &a);
   a = 100;
   \hyperlink{group__Eina__Inline__Array__Group_ga6b9a97816b98ccf9be6b65ca06b90013}{eina\_inarray\_push}(iarr, &a);

\end{DoxyCodeInclude}


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 \hyperlink{group__Eina__Inline__Array__Group_ga8928a9428988a511720ad6b4370f86e6}{eina\+\_\+inarray\+\_\+insert\+\_\+at()}, or we could change the value of the last member using \hyperlink{group__Eina__Inline__Array__Group_gab8fc65cb1a9f7736343f3f6b7e1639ca}{eina\+\_\+inarray\+\_\+replace\+\_\+at()} and then append the values in the right order, but for no particular reason we're going to use \hyperlink{group__Eina__Inline__Array__Group_ga3dfa2e214c3cf3363f6ed390da4221c3}{eina\+\_\+inarray\+\_\+insert\+\_\+sorted()} instead\+: 
\begin{DoxyCodeInclude}
   a = 99;
   \hyperlink{group__Eina__Inline__Array__Group_ga3dfa2e214c3cf3363f6ed390da4221c3}{eina\_inarray\_insert\_sorted}(iarr, &a, cmp);

\end{DoxyCodeInclude}


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\+: 
\begin{DoxyCodeInclude}

   printf(\textcolor{stringliteral}{"Inline array of integers with %d elements:\(\backslash\)n"}, \hyperlink{group__Eina__Inline__Array__Group_gaf6d3ce4a7b0b8e521e2c91024065d97d}{eina\_inarray\_count}(iarr));
   \hyperlink{group__Eina__Inline__Array__Group_gab6ffcad27b5099aa34af9ecd5e2b22f9}{EINA\_INARRAY\_FOREACH}(iarr, b)
     printf("\textcolor{keywordtype}{int}: %d(pointer: %p)\(\backslash\)n", *b, b);

\end{DoxyCodeInclude}


Once done we free our array and shutdown eina\+: 
\begin{DoxyCodeInclude}

   \hyperlink{group__Eina__Inline__Array__Group_ga369b3090b7c04377eaceb6bebfe36e06}{eina\_inarray\_free}(iarr);
   \hyperlink{group__Eina__Main__Group_ga6741fcaba116e31e96ce14dcfa03f568}{eina\_shutdown}();
\}

\end{DoxyCodeInclude}


The source for this example\+: \hyperlink{eina_inarray_01_c}{eina\+\_\+inarray\+\_\+01.\+c} 