WWW-www.enlightenment.org pushed a commit to branch master.
http://git.enlightenment.org/website/www-content.git/commit/?id=ec2efd1a8285fcd812161a365226c03d1b2b5572
commit ec2efd1a8285fcd812161a365226c03d1b2b5572
Author: Xavi Artigas <xavierarti...@yahoo.es>
Date: Thu Nov 9 05:59:35 2017 -0800
Wiki page sidebar changed with summary [] by Xavi Artigas
---
pages/develop/sidebar.txt | 1 +
pages/eina-programming-guide.md.txt | 16 -
pages/eina-programming-guide/arrays.md.txt | 714 ---------------------
.../iterator-functions.md.txt | 24 -
pages/eina-programming-guide/lists.md.txt | 647 -------------------
pages/eina-programming-guide/strings.md.txt | 175 -----
6 files changed, 1 insertion(+), 1576 deletions(-)
diff --git a/pages/develop/sidebar.txt b/pages/develop/sidebar.txt
index 8ec15ea8..d59980ad 100644
--- a/pages/develop/sidebar.txt
+++ b/pages/develop/sidebar.txt
@@ -6,6 +6,7 @@
=== Tutorials ===
* [[/develop/tutorial/c/hello-world | Command Line [Beta]]]
* [[/develop/tutorial/c/eo-intro | Introduction to Eo [Beta]]]
+ * [[/develop/tutorial/c/eo-refcount | Reference Counting in Eo [Beta]]]
* [[/develop/legacy/tutorial/start | Stable API Tutorials]]
diff --git a/pages/eina-programming-guide.md.txt
b/pages/eina-programming-guide.md.txt
deleted file mode 100644
index f3e8f0f1..00000000
--- a/pages/eina-programming-guide.md.txt
+++ /dev/null
@@ -1,16 +0,0 @@
----
-~~Title: Eina Programming Guide~~
-~~NOCACHE~~
----
-
-# Eina Programming Guide #
-
-Just a dummy page to contain and index the documents belonging to the Eina
programming guide, to wit:
-
-* [Iterator
Functions](https://www.enlightenment.org/eina-programming-guide/iterator-functions.md)
-* [Strings](https://www.enlightenment.org/eina-programming-guide/strings.md)
-* [Arrays](https://www.enlightenment.org/eina-programming-guide/arrays.md)
-* [Lists](https://www.enlightenment.org/eina-programming-guide/lists.md)
[UNFINISHED]
-
-
-This can deleted when all the documents in the
playground/eina-programming-guide/ namespace have been moved to their final
resting place.
\ No newline at end of file
diff --git a/pages/eina-programming-guide/arrays.md.txt
b/pages/eina-programming-guide/arrays.md.txt
deleted file mode 100644
index 42362b2c..00000000
--- a/pages/eina-programming-guide/arrays.md.txt
+++ /dev/null
@@ -1,714 +0,0 @@
----
-~~Title: Arrays~~
----
-
-# Arrays #
-
-An array is a data type which describes an ordered collection of values. The
values are accessed by their index.
-
-|INDEX |VALUE |
-|------|------|
-|0 |value0|
-|1 |value1|
-|2 |value2|
-|3 |value3|
-|4 |value4|
-|5 |value5|
-|6 |value6|
-|7 |value7|
-
-Eina provides 2 array types: the **classic array** and an **inline array**.
-
-## Creating and Destroying a Classic Array ##
-
-The ``eina_array_new()`` function creates a new array. You can store strings
or objects in the created array. The function returns a new array, or if memory
allocation fails, ``NULL``.
-
-The first parameter of the ``eina_array_new()`` function defines the size of
the array allocation step. For example, if you set it to 4, the function
returns an array of 4 elements. The next time you grow the array it grows by 4
elements. Unless you have pushed 4 elements inside, it does not grow. But once
you add the 5th element, it grows again and becomes an array of 8 elements. The
allocation step feature is very useful for optimizing performance, and it also
reduces memory fragmentat [...]
-
-### Creating an Array to Store Strings ###
-
-First create the array:
-
-```c
-[...]
-
-// Strings to store in the array
-const char* strings[] =
-{
- "helo", "hera", "starbuck", "kat", "boomer",
- "hotdog", "longshot", "jammer", "crashdown", "hardball",
- "duck", "racetrack", "apolo", "husker", "freaker",
- "skulls", "bulldog", "flat top", "hammerhead", "gonzo"
-};
-// Declaring the array (type Eina_Array)
-Eina_Array *array;
-unsigned int i;
-
-// Creating the array
-array = eina_array_new(20);
-
-// Inserting elements in the array
-for (i = 0; i < 20; i++)
- eina_array_push(array, strdup(strings[i]));
-
-[...]
-```
-> **NOTE:**
-> ``[...]`` in a Code Block indicates there will usually be code above and
below the shown snippet, but that it has been excluded for the sake of brevity.
There is no need to type ``[...]`` into your program.
-
-To change the allocation step, use the ``eina_array_step_set()`` function, the
first parameter is the array you want to change, the second parameter is the
size of that specific array (retrieved with the ``sizeof()`` function) and the
last parameter is the new step size.
-
-In this example, the array step changes from 20 to 30.
-
-```c
-[...]
-eina_array_step_set(array, sizeof(*array), 30);
-[...]
-```
-
-When no longer used, use the ``eina_array_free()`` function to free the array.
It first calls the ``eina_array_flush()`` function and frees the memory of the
pointer. It does not free the memory allocated for the elements of the array.
To do that, use a ``while`` statement with the ``eina_array_pop`` function.
-
-
-```c
-[...]
-// Freeing the array elements
-while (eina_array_count(array))
- free(eina_array_pop(array));
-
- // Freeing the array itself
-eina_array_free(array);
-[...]
-```
-
-## Modifying Classic Array Content ##
-
-### Setting the Data of an Element ###
-Use the ``eina_array_data_set()`` function to set the data of an element. The
first parameter is the array, the second is the index of the element you want
to set, and the last one is the data. You must first get the related pointer if
you need to free it, as this function replaces the previously held data. Be
careful, as there is no array or index check. If the value is ``NULL`` or
invalid, the application can crash.
-
-
-```c
-[...]
-free(eina_array_data_get(array, 0));
-eina_array_data_set(array, 0, strdup(strings[3]);
-[...]
-```
-
-### Adding Elements to the End of an Array ###
-Use the ``eina_array_push()`` function. The function returns ``EINA_TRUE`` on
success, and ``EINA_FALSE`` on failure. The first parameter is the array that
will store the element, the second one is the data you want to store. If you
store strings, remember to allocate the memory first. The following example
uses the ``strdup`` function to duplicate the string contained in
``strings[]``. This function allocates the memory of the returned string, so
you do not have to do it yourself.
-
-
-```c
-[...]
-for (i = 0; i < 20; i++)
- eina_array_push(array, strdup(strings[i]));
-[...]
-```
-
-### Removing the Last Element of an Array ###
-Use the ``eina_array_pop()`` function. It takes the array as a parameter, and
if the operation is successful, returns a pointer to the data of the removed
element.
-
-```c
-[...]
-while (eina_array_count(array))
- free(eina_array_pop(array));
-[...]
-```
-
-### Rebuilding an Array by Specifying the Data to be Kept ###
-
-Use the ``eina_array_remove()`` function. The first parameter is the array to
be changed, the second parameter is the function which selects the data to keep
in the rebuilt array and the last parameter is the data to pass to the selector
function defined as the second parameter.
-
-The selector function has to return an ``Eina_Bool``, ``EINA_TRUE`` if the
element stays, and ``EINA_FALSE`` if it has to be removed.
-
-The following example shows how to remove all the strings from an array that
are longer than 5.
-
-```c
-[...]
-// Selector function
-Eina_Bool keep(void *data, void *gdata)
-{
- if (strlen((const char*)data) <= 5)
- return EINA_TRUE;
-
- return EINA_FALSE;
-}
-
-int remove_array()
-{
- Eina_Array *array;
- Eina_Array_Iterator iterator;
- const char *item;
- unsigned int i;
-
- // Creating and populating an array
-
- // Removing the undesired elements
- eina_array_remove(array, keep, NULL);
-
- // Flushing and freeing the array
-
- return 0;
-}
-[...]
-```
-
-### Wiping all Data from an Array ###
-
-Use the ``eina_array_flush()`` function. This function sets the count and
total members of an array to 0, and frees and sets its data members to
``NULL``. For performance reasons, there is no array check. If the value is
``NULL`` or invalid, the program can crash. The only parameter of this function
is a pointer to the ``Eina_Array`` array you want to flush.
-
-```c
-[...]
-eina_array_flush(array);
-[...]
-```
-
-### Emptying an Array Quickly ###
-
-Use the ``eina_array_clean()`` function. This function sets the counting of
members in the array to 0. It does not free any space so you have to use it
carefully. For performance reasons, there is no array check. If the value is
``NULL`` or invalid, the program can crash.
-
-
-```c
-[...]
-eina_array_clean(array);
-[...]
-```
-
-## Accessing Classic Array Data ##
-
-### Accessing the Data in an Array ###
-
-Use the ``eina_array_data_get()`` function with the array and the index of the
element you want to get. The function returns a pointer to the data.
-
-```c
-[...]
-// Getting the data of the first element
-char *mydata;
-mydata = eina_array_data_get(array, 0);
-[...]
-```
-
-### Getting the Number of Elements in an Array ###
-
-Use the ``eina_array_count()`` function. The first parameter is a pointer to
the array variable returned by the ``eina_array_new()`` function. The function
returns the number of elements.
-
-```c
-[...]
-unsigned int nb_elm;
-nb_elm = eina_array_count(array);
-[...]
-```
-
-### Iterating through an Array ###
-
-You can use various methods:
-
-#### Using the ``ITER_NEXT`` iterator ####
-
-You can use the iterator by calling the macro ``EINA_ARRAY_ITER_NEXT()``. It
takes the array to iterate as the first parameter, a counter for the current
index during the iteration, and a variable of the same type as the item data
and an ``Eina_Iterator``. To use it, declare an ``Eina_Iterator``, an ``int``
counter, and, for example, a ``char *`` item if your array contains strings.
-
-```c
-[...]
-Eina_Array_Iterator iterator;
-const char *item;
-unsigned int i;
-
-EINA_ARRAY_ITER_NEXT(array, i, item, iterator)
- printf("item #%d: %s\n", i, item);
-[...]
-```
-
-#### Using the ``eina_array_foreach()`` Function ####
-
-The first parameter is the array to iterate, the second is a callback function
which determines whether the iteration can continue, and the last is the data
passed to the callback function.
-
-To iterate over the array and to print the data of each array element, you can
do:
-
-```c
-[...]
-// Callback function
-static Eina_Bool
-elm_print(const void *container, void *data, void *fdata)
-{
- printf("%s\n", (char *)data);
-
- return EINA_TRUE;
-}
-
-int iterating_array()
-{
- Eina_Array *array;
- unsigned int i;
-
- // Creating and populating an array
-
- // Iterating over the array and calling elm_print on each element
- eina_array_foreach(array, elm_print, NULL);
-
- // Freeing the element data and array
-
- return 0;
-}
-[...]
-```
-#### Using the ``eina_array_iterator_new()`` Function ####
-
-This function returns a newly allocated iterator associated with the array. If
the array is ``NULL`` or the count of the array members is less than or equal
to 0, the function returns ``NULL``. If the memory cannot be allocated,
``NULL`` is returned and ``EINA_ERROR_OUT_OF_MEMORY`` is thrown. Otherwise, a
valid iterator is returned. Pass the array for which you want to create a new
iterator to this function. The iterator is used to run a sequential walk
through the array, just like the ` [...]
-
-To create an iterator and use it to print the data of each array element, you
can do this:
-
-```c
-[...]
-static Eina_Bool
-print_one(const void *container, void *data, void *fdata)
-{
- printf("%s\n", (char*)data);
-
- return EINA_TRUE;
-}
-
-int new_iterator()
-{
- Eina_Array *array;
- Eina_Iterator *it;
- unsigned short int i;
- void *uninteresting;
- Eina_Bool rt;
-
- // Creating and populating an array
-
- it = eina_array_iterator_new(array);
-
- it = eina_iterator_next(it, &uninteresting);
- eina_iterator_foreach(it, print_one, NULL);
- eina_iterator_free(it);
-
- return 0;
-}
-[...]
-```
-
-#### Using the ``eina_array_accessor_new()`` Function to Randomly access Array
Elements ####
-
-The function returns a newly allocated accessor associated with the array. If
the array is ``NULL`` or the counting of array members is less than or equal to
0, this function returns ``NULL``. If the memory cannot be allocated, ``NULL``
is returned and ``EINA_ERROR_OUT_OF_MEMORY`` is thrown. Otherwise, a valid
accessor is returned.
-
-To use the accessor to retrieve and print the data of every other array
element, you can do this:
-
-```c
-[...]
-int random_access()
-{
- Eina_Array *array; // Declaration of the array
- Eina_Accessor *acc; // Declaration of the accessor
-
- unsigned short int i; // Generic counter
-
- void *data; // Variable to put the data retrieved from an
array element
-
- // Creating and populating an array
-
- // Creating the array accessor
- acc = eina_array_accessor_new(array);
-
- // Random access to the data of the array elements
- for(i = 1; i < 10; i += 2)
- {
- // Putting the data in the variable 'data'
- eina_accessor_data_get(acc, i, &data);
- printf("%s\n", (const char *)data);
- }
-
- eina_accessor_free(acc); // Freeing the accessor
-
- // Freeing the array
- return 0;
-}
-[...]
-```
-
-## Creating and Destroying Inline Arrays ##
-
-An inline array is a container that stores the data itself, not the pointers
to the data. This means there is no memory fragmentation, and for small data
types, such as char, short, and int, it is more memory-efficient. This is
because the data is stored in the cache and is faster to access. The bigger the
data gets, however, the less likely it is and the less interesting it becomes.
-
-To create an inline array, use the ``eina_inarray_new()`` function. The first
parameter of this function is the size of the value. In this example, only the
characters are stored, and because of that, only ``sizeof(char)`` is passed to
the function. The second parameter defines the size of the array allocation
step. For example, if you set it to 4, the function returns an inline array of
4 elements, and the next time you grow the inline array, it grows by 4 elements
and becomes an array [...]
-
-The ``eina_inarray_new()`` function returns a pointer to the new
``Eina_Inarray`` variable.
-
-```c
-[...]
-int inline_array()
-{
- Eina_Inarray *iarr; // Declare an inline array
variable of the type Eina_Inarray
-
- iarr = eina_inarray_new(sizeof(char), 0); // Create an inline array of
"char"
-
- eina_inarray_free(iarr); // When no longer needed, free
the array memory
-
- return 0;
-}
-[...]
-```
-
-## Modifying Inline Array Content ##
-
-### Adding Data to the end of and Inline Array ###
-
-Use the ``eina_inarray_push()`` function. The first parameter is a pointer to
the array variable returned by the ``eina_inarray_new()`` function. The second
parameter is the data you want to push to the inline array.
-
-If everything runs fine, the function returns the index of the new element. If
something goes wrong, it returns ``-1``.
-
-```c
-[...]
-ch = 'a';
-eina_inarray_push(iarr, &ch);
-[...]
-```
-
-### Inserting Data to a Given Position within an Inline Array ###
-
-Use the ``eina_inarray_insert_at()`` function. The first parameter is a
pointer to the array variable returned by the ``eina_inarray_new()`` function.
The second parameter is the index of the element you want to add to the inline
array. The last parameter is a pointer to the content to be added.
-
-The content of the pointer is copied to the given position in the inline
array. All the members from the position to the end of the array are shifted
towards the end. If the position is equal to the end of the array, the member
is appended. If the position is bigger than the array length, the function
fails.
-
-
-```c
-[...]
-ch = 'a';
-eina_inarray_push(iarr, &ch);
-ch = 'b';
-eina_inarray_push(iarr, &ch);
-ch = 'd';
-eina_inarray_push(iarr, &ch);
-
-// Adding data on position 3
-ch = 'c';
-eina_inarray_insert_at(iarr, 2, &ch)
-[...]
-```
-
-### Inserting Data Using your own Position Criteria ###
-
-Use the ``eina_inarray_insert()`` or ``eina_inarray_insert_sorted()``
function. The only difference between these functions is that the
``eina_inarray_insert_sorted()`` function assumes that the array is already
sorted and consequently optimizes the insertion position by doing a binary
search.
-
-In both functions, the first parameter is a pointer to the array variable
returned by the ``eina_inarray_new()`` function. The second parameter is the
data you want to push to the inline array. The last parameter is the callback
comparison function.
-
-The ``Eina_Compare_Cb`` callback function compares data1 and data2, data1
being the value contained in the inline array and data2 the data you pass to
the ``eina_inarray_insert()`` or ``eina_inarray_insert_sorted()`` function as
the second parameter. If data1 is less than data2, the function returns -1, if
it is greater, it returns 1. If they are equal, it returns 0.
-
-The following example shows how to insert a value before a greater value:
-
-```c
-[...]
-// Defining the comparison function with the position criteria
-Eina_Compare_Cb cmp(const void *a, const void *b)
-{
- return *(int*)a > *(int*)b;
-}
-
-int inline_insert()
-{
- Eina_Inarray *iarr;
- char ch, *ch3;
- int a, *b;
-
- // Creating an inline array
-
- // Adding data to the inline array
- a = 97;
- eina_inarray_push(iarr, &a);
- a = 98;
- eina_inarray_push(iarr, &a);
- a = 100;
- eina_inarray_push(iarr, &a);
-
- // Inserting data with the criteria
- a = 99;
- eina_inarray_insert_sorted(iarr, &a, cmp);
-
- eina_inarray_free(iarr);
-}
-[...]
-```
-
-### Removing the Last Element from an Inline Array ###
-
-Use the ``eina_inarray_pop()`` function. The only parameter is a pointer to
the array variable returned by the ``eina_inarray_new()`` function. This
function returns the data removed from the inline array.
-
-```c
-[...]
-eina_inarray_pop(iarr);
-[...]
-```
-
-### Removing Specific Data from an Inline Array ###
-
-Use the ``eina_inarray_remove()`` function. The first parameter is a pointer
to the array variable returned by the ``eina_inarray_new()`` function. The
second parameter is the data you want to remove from the inline array.
-
-The ``eina_inarray_remove()`` function finds the data and removes the matching
members from the array. The data can be an existing member of an inline array
for optimized usage. In other cases, the content is matched using the
``memcmp()`` function.
-
-The ``eina_inarray_remove()`` function returns the index of the removed
member, or -1 if it failed.
-
-```c
-[...]
-iarr = eina_inarray_new(sizeof(char), 0);
-
-ch = 'a';
-eina_inarray_push(iarr, &ch);
-
-// Removing data from the array
-eina_inarray_remove(iarr, &ch);
-[...]
-```
-
-### Removing Data from a Specific Position within an Inline Array ###
-
-Use the ``eina_inarray_remove_at()`` function. The first parameter is a
pointer to the array variable returned by the ``eina_inarray_new()`` function.
The second parameter is the index of the element you want to remove from the
inline array.
-
-The function returns ``EINA_TRUE`` on success and ``EINA_FALSE`` if something
goes wrong. The member is removed from the inline array and any members after
it are moved forward towards the array's head.
-
-```c
-[...]
-// Removing data from position 2
-eina_inarray_remove_at(iarr, 2);
-[...]
-```
-
-### Removing all Elements from an Array ###
-
-Use the ``eina_inarray_flush()`` function. The first parameter is a pointer to
the array variable returned by the ``eina_inarray_new()`` function. The
function removes every member from the array.
-
-
-```c
-[...]
-eina_inarray_flush(iarr);
-[...]
-```
-
-### Replacing Values in an Inline Array ###
-
-Use the ``eina_inarray_replace_at()`` function, which copies the data over the
given position. The first parameter is a pointer to the array variable returned
by the ``eina_inarray_new()`` function. The second parameter is the index of
the element you want to remove from the inline array. The last parameter is the
data you want to copy in place of the current data.
-
-The function returns ``EINA_TRUE`` on success, and ``EINA_FALSE`` on failure.
The given pointer content is copied to the given position in the array. The
pointer is not referenced, instead its contents are copied to the member's
array using the previously defined ``member_size``. If the position does not
exist, the function fails.
-
-
-```c
-[...]
-// Replacing the member at position 3
-ch = 'd';
-eina_inarray_replace_at(iarr, 3, &ch);
-[...]
-```
-
-### Sorting an Inline Array ###
-
-Use the ``eina_inarray_sort()`` function, which applies a quick sorting
algorithm to the inline array. The first parameter is a pointer to the array
returned by the ``eina_inarray_new()`` function. The last parameter is the
``Eina_Compare_Cb`` callback comparison function, which compares **data1** and
**data2**. **data1** and **data2** are values contained in the inline array. If
the data matches, the function returns 0; if data1 is smaller than data2, it
returns -1; and if it is greater [...]
-
-
-```c
-[...]
-static int
-short_cmp(const void *pa, const void *pb)
-{
- const short *a = pa, *b = pb;
-
- return *a - *b;
-}
-
-int sorting_inline_array()
-{
- Eina_Inarray *array;
- int i;
-
- // Creating and populating the inline array
-
- eina_inarray_sort(array, short_cmp);
- eina_inarray_free(array);
-}
-[...]
-```
-
-Be careful: the data given to the compare function is the pointer to the
member memory itself. Do not change it.
-
-## Accessing Inline Array Data ##
-
-### Search for a Member in an Inline Array ###
-
-Use the ``eina_inarray_search()`` function that runs a linear walk looking for
the given data
-
-The first parameter is a pointer to the array variable returned by the
``eina_inarray_new()`` function. The second parameter is the data used by the
callback function to run the comparison. The last parameter is the
``Eina_Compare_Cb`` callback comparison function, which compares **data1** and
**data2**. **data1** is the value contained in the inline array and **data2**
is the data you pass to the ``eina_inarray_search()`` function as the second
parameter. If the data matches, the functi [...]
-
-The function returns the member index, or -1 if not found.
-
-```c
-[...]
-
-Eina_Compare_Cb
-compare(const void *pa, const void *pb)
-{
- const short *a = pa, *b = pb;
- if (*a == *b)
- return EINA_TRUE;
-
- return EINA_FALSE;
-}
-
-int search_inline_array()
-{
- Eina_Inarray *array;
- int i;
- int elm_index;
- int to_search = 3;
-
- // Creating and populating the inline array
-
- elm_index = eina_inarray_search(array, &to_search, compare);
- eina_inarray_free(array);
-}
-[...]
-```
-
-Note that the data given to the compare function is the pointer to the member
memory itself. Do not change it.
-
-The ``eina_inarray_search_sorted()`` function does exactly the same as
``eina_inarray_search()``, but uses a binary search for the given data.
-
-### Retrieving the Number of Elements in an Inline Array ###
-
-Use the ``eina_inarray_count()``. The parameter is a pointer to the array
returned by the ``eina_inarray_new()`` function. The function returns an
``unsigned int``, the number of elements.
-
-```c
-[...]
-printf("Inline array of integers with %d elements:\n",
eina_inarray_count(iarr));
-[...]
-```
-
-### Iterating over an Inline Array ###
-
-You can use two methods to iterate over the items contained in an inline array:
-
-1. You can use the iterator macros for the inline arrays: ``FOREACH`` and
``REVERSE_FOREACH``.
-
-2. Running a linear walk over an array of elements, use the
``EINA_INARRAY_FOREACH()`` macro. The first parameter is a pointer to the array
variable returned by ``eina_inarray_new()``, and the second parameter is the
variable into which the current value is put during the walk. The
``EINA_INARRAY_REVERSE_FOREACH()`` macro does the same thing but starts from
the last element.
-
-The following example illustrates the printing of each element and its pointer:
-
-
-```c
-[...]
-iarr = eina_inarray_new(sizeof(char), 0);
-int a, *b;
-
-a = 97;
-eina_inarray_push(iarr, &a);
-a = 98;
-eina_inarray_push(iarr, &a);
-a = 99;
-eina_inarray_push(iarr, &a);
-
-EINA_INARRAY_FOREACH(iarr, b)
- printf("int: %d(pointer: %p)\n", *b, b);
-[...]
-```
-
-To process the array data, use the ``eina_inarray_foreach()`` function, which
invokes the given function on each element of the array with the given data.
The first parameter is a pointer to the array variable returned by
``eina_inarray_new()``. The second parameter is the function to run on each
element. The function must return ``EINA_TRUE`` as long as you want to continue
iterating. By returning ``EINA_FALSE``, you stop the iteration and make the
``eina_inarray_foreach()`` function re [...]
-
-The last parameter is the data passed to the function called on each element.
-
-The ``eina_inarray_foreach()`` function returns ``EINA_TRUE`` if it
successfully iterates through all items of the array. Call the function for
every given data in the array. This is a safe way to iterate over an array.
-
-
-```c
-[...]
-static Eina_Bool
-array_foreach(const void *array __UNUSED__, void *p, void *user_data
__UNUSED__)
-{
- short *member = p;
- int *i = user_data;
- (*p)++;
- (*i)++;
-
- return EINA_TRUE;
-}
-
-int inline_array_foreach()
-{
- Eina_Inarray *iarr;
- iarr = eina_inarray_new(sizeof(char), 1);
- int i;
-
- for (i = 0; i < numbers_count; i++)
- {
- short val = i;
- eina_inarray_push(iarr, &val);
- }
-
- i = 0;
- eina_inarray_foreach(iarr, array_foreach, &i);
-
- eina_inarray_free(iarr);
-
- return 0;
-}
-[...]
-```
-
-### Removing some Elements Based on Your Own Criteria ###
-
-Use the ``eina_inarray_foreach_remove()`` function, which walks through the
array and, if the value matches in the callback function, removes the element.
The first parameter is a pointer to the array returned by
``eina_inarray_new()`` function. The second parameter is the callback function
to run on each element. \\ \\ The callback function returns ``EINA_TRUE`` if
the value matches, or ``EINA_FALSE`` if it does not match. The last parameter
is the data passed to the callback function.
-
-The function returns the number of removed entries or -1 if something goes
wrong.
-
-```c
-[...]
-static Eina_Bool
-array_foreach(const void *array __UNUSED__, void *p, void *user_data
__UNUSED__)
-{
- short *member = p;
- int *i = user_data;
- if (*i == *p)
- return EINA_TRUE;
-
- return EINA_FALSE;
-}
-
-int inline_array_foreach_remove()
-{
- Eina_Inarray *iarr;
- iarr = eina_inarray_new(sizeof(char), 1);
- int i;
-
- for (i = 0; i < numbers_count; i++)
- {
- short val = i;
- eina_inarray_push(iarr, &val);
- }
-
- i = 6;
- eina_inarray_foreach_remove(iarr, array_foreach, &i);
-
- eina_inarray_free(iarr);
-
- return 0;
-}
-[...]
-```
-
-## Further Reading ##
-
-[Array
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__Array__Group.html)
-: Functions that provide array management.
-
-[Array Example
1](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_array_01_8c-example.html)
-: Example of array usage 1.
-
-[Array Example
2](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_array_02_8c-example.html)
-: Example of array usage 2.
-
-[Inline Array
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__Inline__Array__Group.html)
-: Functions that provide inline array management.
-
-[Inline Array Example
1](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_inarray_01_8c-example.html)
-: Example of inline array usage 1.
-
-[Inline Array Example
2](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_inarray_02_8c-example.html)
-: Example of inline array usage 2.
-
-[Inline Array Example
3](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_inarray_02_8c-example.html)
-: Example of inline array usage 3.
\ No newline at end of file
diff --git a/pages/eina-programming-guide/iterator-functions.md.txt
b/pages/eina-programming-guide/iterator-functions.md.txt
deleted file mode 100644
index 8ed042dd..00000000
--- a/pages/eina-programming-guide/iterator-functions.md.txt
+++ /dev/null
@@ -1,24 +0,0 @@
----
-~~Title: Iterator Functions~~
-~~NOCACHE~~
----
-
-# Iterator Functions #
-
-Eina provides a set of iterator functions to manipulate data types, such as
arrays.
-
-These functions allow access to container elements in a generic way, without
knowing which container is used (similar to iterators in the C++ STL).
Iterators only allow sequential access (that is, from one element to the next
one). For random access, Eina provides accessor functions.
-
-Getting an iterator to access elements of a given container is done through
the functions of that particular container. There is no function to create a
generic iterator as iterators absolutely depend on the container. Note that all
iterators, regardless of the container type, are always deleted with the same
``eina_iterator_free()`` function.
-
-To get the data and iterate, use the ``eina_iterator_next()`` function. To
call a function on every single element of a container, use the
``eina_iterator_foreach()`` function.
-
-In addition to iterator functions, each data type also owns a set of macros
that provide the iterators, such as ``FOREACH`` or ``REVERSE_FOREACH``.
-
-## Further Reading ##
-
-[Iterator Functions
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__Iterator__Group.html)
-: The functions that manage iterators on containers.
-
-[Eina Iterator
Example](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_iterator_01_8c-example.html)
-: An example using iterator functions.
\ No newline at end of file
diff --git a/pages/eina-programming-guide/lists.md.txt
b/pages/eina-programming-guide/lists.md.txt
deleted file mode 100644
index 71f82b3e..00000000
--- a/pages/eina-programming-guide/lists.md.txt
+++ /dev/null
@@ -1,647 +0,0 @@
-{{page>index}}
--------
-# Lists #
-
-The ``Eina_List`` is a double-linked list that can store data of any type as
-void pointers. It provides a set of functions to create and manipulate the
-list to avoid the access to the struct's fields, similar to a self-made
-double-link list.
-
-In addition to the previous and next node and its data, the ``Eina_List``
-nodes keep a reference to an accounting structure. The accounting structure is
-used to improve the performance of some functions. The structure is private
-and must not be modified.
-
-In an ``Eina_List``, everything is a "list": the list itself is a list where
-each node is a list as well.
-
-Eina provides 2 list types: the classic list (``Eina_List``) and an inline
-list (``Eina_Inlist``).
-
-## Creating and Destroying a List ##
-
-To use an ``Eina_List``:
-
-__**1**__. Declare the list with ``NULL`` as the default value:
-
-```c
-[...]
-int list()
-{
- // Declaration of the Eina_List with NULL as default value;
- Eina_List *list = NULL;
-[...]
-```
-
-__**2**__. Call the ``eina_list_append()`` function with the list and the data
you
-want to append as parameters.
-
-The list must be a pointer to the first element of the list (or ``NULL``). The
-function returns a pointer to the list.
-
-```c
-[...]
- // Creating the first element of the list
- list = eina_list_append(list, "watch");
-
- // Adding more elements
- list = eina_list_append(list, "phone");
- list = eina_list_append(list, "ivi");
- list = eina_list_append(list, "notebook");
-[...]
-```
-
-__**3**__. When you no longer need the list, free it:
-
-```c
-[...]
- // Free the Eina_List
- eina_list_free(list);
-
- return 0;
-}
-[...]
-```
-
-## Modifying List Content ##
-
-### To add data to a list ###
-
- * To add data at the end of the list, use the ``eina_list_append()``
function. To add data at the top of the list, use ``eina_list_prepend()``. The
functions work in the same way, only adding the data to different places.
-
-```c
-[...]
-list = eina_list_prepend(list, "set-top box");
-[...]
-```
-
- * To insert data into the list after a specified data, use the
``eina_list_append_relative()`` function. As the last parameter, define the
element after which the data is added. \\ \\ For example to append data after
the "phone" element:
-
-```c
-[...]
-list = eina_list_append_relative(list, "single-board computer", "phone");
-[...]
-```
-
- * To add a new entry before a specified data, use the
``eina_list_prepend_relative()`` function. It is similar to the
``eina_list_append_relative()`` function.
-
-```c
-[...]
-list = eina_list_prepend_relative(list, "ultrabook", "ivi");
-[...]
-```
-
- * To append a list node to a linked list after a specified member, use the
``eina_list_append_relative_list()`` function. To prepend a list node to a
linked list before a specified member, use the ``Eina_List *
eina_list_prepend_relative_list()`` function.
-
-### To set data in a list member ###
-Use the ``eina_list_data_set()`` function. Pass the
-"list" (node) as the first argument and the data to set as the second.
-
-The following example also shows the usage of the ``eina_list_last()``
-function, which returns the last element of an ``Eina_List``.
-
-```c
-[...]
-// Setting new data for the last element
-eina_list_data_set(eina_list_last(list), eina_stringshare_add("Boris"));
-[...]
-```
-
-### To remove a node from the list ###
-
-Use the ``eina_list_remove()`` function. This function removes the first
-instance of the specified data from the given list.
-
-```c
-[...]
-list = eina_list_remove(list, "ultrabook");
-[...]
-```
-
-You can also remove a "list" (node) from a list using the
-``eina_list_remove_list()`` function. Pass the list you want to delete an
-element from and a 'list' (node) you want to delete.
-
-```c
-[...]
-Eina_List *app_list = NULL;
-Eina_List *to_remove = NULL;
-
-// Adding some elements to the list (using stringshares)
-app_list = eina_list_append(app_list, eina_stringshare_add("enna"));
-app_list = eina_list_append(app_list, eina_stringshare_add("ebird"));
-app_list = eina_list_append(app_list, eina_stringshare_add("calaos"));
-app_list = eina_list_append(app_list, eina_stringshare_add("rage"));
-app_list = eina_list_append(app_list, eina_stringshare_add("terminology"));
-app_list = eina_list_append(app_list, eina_stringshare_add("enlightenment"));
-app_list = eina_list_append(app_list, eina_stringshare_add("eyelight"));
-app_list = eina_list_append(app_list, eina_stringshare_add("ephoto"));
-
-// Finding the "list" to remove
-to_remove = eina_list_data_find_list(list,
eina_string_share_add("enlightenment"));
-
-list = eina_list_remove_list(list, to_remove);
-[...]
-```
-
-### To move elements in a list ###
-
-You can use various function, such as ``eina_list_promote_list()`` that
-promotes an element to the top of the list or ``eina_list_demote_list()`` that
-puts the specified element at the end of the list. Remember that everything is
-a list so the second parameter represents the "list" (node) you want to move.
-Use the functions just like the ``eina_list_remove_list()`` function.
-
-```c
-[...]
-list = eina_list_promote_list(list, eina_list_data_find_list(list, "ivi"));
-[...]
-```
-
-### To reverse all the elements of a list ###
-
-Use the ``eina_list_reverse()`` function. To obtain a reversed copy of the
-list while keeping the initial list unchanged, use the
-``eina_list_reverse_clone()`` function.
-
-```c
-[...]
-Eina_List *rev_copy;
-
-app_list = eina_list_reverse(app_list);
-rev_copy = eina_list_reverse_clone(app_list);
-[...]
-```
-
-### To sort a list ###
-
-Use the ``eina_list_sort()`` function. This function takes a list which needs
-to be sorted, the maximum number of elements to be sorted, and a callback
-function that compares data. To sort all list elements, set the maximum number
-of elements to 0.
-
-```c
-[...]
-int sort_cb(const void *d1, const void *d2)
-{
- const char *txt = d1;
- const char *txt2 = d2;
- if(!txt) return(1);
- if(!txt2) return(-1);
-
- return(strcmp(txt, txt2));
-}
-
-extern Eina_List *list;
-list = eina_list_sort(list, 0, sort_cb);
-[...]
-```
-
-### To merge 2 list into 1 ###
-
-Use the ``eina_list_merge()`` function. The ``eina_list_sorted_merge()``
-function merges 2 sorted lists according to the ordering function that you
-pass as the last argument.
-
-```c
-[...]
-int sort_cb(void *d1, void *d2)
-{
- const char *txt = NULL;
- const char *txt2 = NULL;
- if(!d1) return(1);
- if(!d2) return(-1);
-
- return(strcmp((const char*)d1, (const char*)d2));
-}
-
-Eina_List *sorted1;
-Eina_List *sorted2;
-Eina_List *newlist;
-
-// Insert some values and sort your lists
-
-// Simply merge 2 lists without any process
-newlist = eina_list_merge(sorted1, sorted2);
-
-newlist = eina_list_sorted_merge(sorted1, sorted2, sort_cb);
-[...]
-```
-
-### To split a list ###
-
-Use the eina_list_split_list() function:
- * The first parameter is the list to split.
- * The second parameter is the "list" (element) after which the list is
split.
- * The last parameter is the head of the second list.
-
-```c
-[...]
-// Original list (left list)
-Eina_List *list = NULL;
-
-// New list (right list)
-Eina_List *other_list = NULL;
-
-// Eina_List (element)
-Eina_List *l;
-
-list = eina_list_append(list, "super tux");
-list = eina_list_append(list, "frozen bubble");
-list = eina_list_append(list, "lincity-ng");
-
-// Sorting the list (just for fun)
-list = eina_list_sort(list, 0, cmp_func);
-
-// Looking for the 'split' element
-l = eina_list_search_sorted_list(list, cmp_func, "frozen bubble");
-
-// Splitting the list
-list = eina_list_split_list(list, l, &other_list);
-[...]
-```
-
-### To copy a list ###
-
-Use the ``eina_list_clone()`` function. The function copies all the elements
-in the list in the exact same order.
-
-```c
-[...]
-Eina_List *app_list_copy;
-
-app_list_copy = eina_list_clone(app_list);
-[...]
-```
-
-## Accessing List Data ##
-
-### To find some data on your list ###
-
-Use the ``eina_list_data_find()`` function. Pass the list containing your data
-as the first parameter and the data you are looking for as the last one. The
-function returns the found member data pointer if found, ``NULL`` otherwise.
-
-The ``eina_list_data_find()`` function searches the list from the beginning to
-the end for the first member for which the data pointer is data. If it is
-found, the data is returned, otherwise ``NULL`` is returned. The function only
-compares pointers, which is why using ``Eina_Stringshare`` is very useful with
-lists, because it always returns the same pointer for the same string.
-
-```c
-[...]
-Eina_List *app_list = NULL;
-const char *res_str;
-
-// Adding some elements to the list (using stringshares)
-app_list = eina_list_append(app_list, eina_stringshare_add("enna"));
-app_list = eina_list_append(app_list, eina_stringshare_add("ebird"));
-app_list = eina_list_append(app_list, eina_stringshare_add("calaos"));
-app_list = eina_list_append(app_list, eina_stringshare_add("rage"));
-app_list = eina_list_append(app_list, eina_stringshare_add("terminology"));
-app_list = eina_list_append(app_list, eina_stringshare_add("enlightenment"));
-app_list = eina_list_append(app_list, eina_stringshare_add("eyelight"));
-app_list = eina_list_append(app_list, eina_stringshare_add("ephoto"));
-
-// Finding the data
-res_str = eina_list_data_find(list, eina_string_share_add("enlightenment"));
-if (res_str #### eina_stringshare_add("enlightenment"))
- printf("Data is present");
-else
- printf("Data not present");
-[...]
-```
-
-The above example returns "Data is present".
-
-The ``eina_list_data_find_list()`` function does the same thing as
-``eina_list_data_find()``, but returns an ``Eina_List``. For an example, see
-the ``eina_list_remove_list()`` function.
-
-You can access the data or a "list" (node) of an ``Eina_List`` using the
-``eina_list_nth()`` and ``eina_list_nth_list()`` functions. The first one
returns a
-pointer to the data of the "n" element and the second a pointer to the "list".
-To access the data of the 3rd element of an ``Eina_List``:
-
-```c
-[...]
-const char *res;
-Eina_List *res_lst;
-
-res = eina_list_nth(app_list, 2);
-res_lst = eina_list_nth_list(app_list, 2);
-[...]
-```
-
-The ``res`` variable contains the pointer to the string "calaos". The
-``res_lst`` variable is the list containing "calaos".
-
-### To search for data in a list ###
-
-Select your function based on whether the list is sorted or unsorted.
- * To search in an unsorted list, use the ``eina_list_search_unsorted()``
function:
- * The first parameter is the list.
- * The second parameter is a callback function for comparison.
- * The last parameter is the data you are looking for.
-
-The ``eina_list_search_unsorted_list()`` function does the same but returns an
-"Eina_List".
-
-The following example shows 2 searches using both the
-``eina_list_search_unsorted()`` and ``eina_list_search_unsorted_list()``
-functions:
-
-```c
-[...]
-int search_list()
-{
- // Declaring the list
- Eina_List *list = NULL;
- Eina_List *l;
- // Little trick to use strcmp as Eina_Compare_Cb
- Eina_Compare_Cb cmp_func = (Eina_Compare_Cb)strcmp;
-
- void *data;
- int cmp_result;
-
- list = eina_list_append(list, "debian");
- list = eina_list_append(list, "archlinux");
- list = eina_list_append(list, "centos");
-
- data = eina_list_search_unsorted(list, cmp_func, "archlinux");
- l = eina_list_search_unsorted_list(list, cmp_func, "archlinux");
- if (l->data != data)
- {
- eina_list_free(list);
-
- return 1;
- }
-
- eina_list_free(list);
-
- return 0;
-}
-[...]
-```
- * To search in sorted lists, use the ``eina_list_search_sorted_list()`` and
``eina_list_search_sorted()`` functions. They work similarly as the
``eina_list_search_unsorted()`` function.
-
-### To get data from a list element ###
-
-Use the ``eina_list_data_get()`` function. The function returns the data
-contained in the given list.
-
-The following example uses the ``eina_list_next()`` function to move through
-the list in a statement.
-
-```c
-[...]
-int list_data_set()
-{
- // Declaring the list
- Eina_List *list = NULL;
- // Eina_List in which to place the elements or lists
- Eina_List *l;
-
- void *list_data;
-
- list = eina_list_append(list, eina_stringshare_add("Bertrand"));
- list = eina_list_append(list, eina_stringshare_add("Cedric"));
- list = eina_list_append(list, eina_stringshare_add("Nicolas"));
- list = eina_list_append(list, eina_stringshare_add("Vincent"));
- list = eina_list_append(list, eina_stringshare_add("Raoul"));
- list = eina_list_append(list, eina_stringshare_add("Fabien"));
- list = eina_list_append(list, eina_stringshare_add("Philippe"));
- list = eina_list_append(list, eina_stringshare_add("billiob"));
-
- for(l = list; l; l = eina_list_next(l))
- // Printing the data returned by eina_list_data_get
- printf("%s\n", (char*)eina_list_data_get(l));
-
- EINA_LIST_FREE(list, list_data)
- eina_stringshare_del(list_data);
-
- return 0;
-}
-[...]
-```
-
-### To move in a list ###
-
-Use the ``eina_list_last()``, ``eina_list_next()``, or ``eina_list_prev()``
-functions to move to the last, next, or previous element in the list.
-
-The following example scrolls backwards starting from the end of the list:
-
-```c
-[...]
-
-for(l = eina_list_last(list); l; l = eina_list_prev(l))
- printf("%s\n", (char*)eina_list_data_get(l));
-[...]
-```
-
-### To count the list elements ###
-
-Use the ``eina_list_count()`` function. The function returns the number of
-items in a list.
-
-```c
-[...]
-printf("List size: %d\n", eina_list_count(list));
-[...]
-```
-
-### To iterate through an array ###
-
-You can use various iterators:
-
- * To iterate over a list from the beginning to the end, use the
``EINA_LIST_FOREACH`` macro:
- * The first parameter is the list to iterate.
- * The second parameter is an ``Eina_List *`` to hold the current "List"
(node).
- * The last parameter receives the current data during the run.
-
-The following example prints the data of each "List" (node) of the list:
-
-```c
-[...]
-Eina_List *list = NULL;
-Eina_List *l;
-void *list_data;
-
-list = eina_list_append(list, "ls");
-list = eina_list_append(list, "top");
-list = eina_list_append(list, "rmdir");
-list = eina_list_append(list, "uname");
-
-EINA_LIST_FOREACH(list, l, list_data)
- printf("%s\n", (char*)list_data);
-
-eina_list_free(list);
-[...]
-```
-
- * To iterate from the last element to the first, use the
``EINA_LIST_REVERSE_FOREACH`` macro. It works similarly as
``EINA_LIST_FOREACH()``.
- * To iterate over a list from the beginning to the end, you can also use the
-``EINA_LIST_FOREACH_SAFE`` macro. It is called safe, because it stores the
next "List" (node), so you can safely remove the current "List" (node) and
continue the iteration.
-
-```c
-[...]
-Eina_List *list;
-Eina_List *l;
-Eina_List *l_next;
-char *data;
-
-list = eina_list_append(list, "enlightenment");
-list = eina_list_append(list, "enlightenment");
-list = eina_list_append(list, "enlightenment");
-list = eina_list_append(list, "enlightenment");
-
-// Using EINA_LIST_FOREACH_SAFE to free the elements that match "enlightenment"
-
-EINA_LIST_FOREACH_SAFE(list, l, l_next, data)
- if (strcmp(data, "enlightenment") #### 0)
- {
- free(data);
- list = eina_list_remove_list(list, l);
- }
-[...]
-```
-
- * To remove each list element while having access to the node's data, use
the ``EINA_LIST_FREE`` macro. Pass the list and a pointer to hold the current
data.
-
-```c
-[...]
-Eina_List *list;
-char *data;
-
-// List is filled
-
-EINA_LIST_FREE(list, data)
- free(data);
-[...]
-```
-
-## Using an Inline List ##
-
-The ``Eina_Inlist`` is a special data type drawn to store nodes pointers in
-the same memory as data. This way the memory is less fragmented, but
-operations, such as sort and count, are slower. The ``Eina_Inlist`` has its
-own purpose, but if you do not understand what the purpose is, use the regular
-``Eina_List`` instead.
-
-The ``Eina_Inlist`` nodes can be part of a regular ``Eina_List``, simply added
-with the ``eina_list_append()`` or ``eina_list_prepend()`` functions.
-
-To use the inline list:
-
-__**1**__. Define the structure of the data before creating the inline list:
-
-```c
-[...]
-struct my_struct
-{
- EINA_INLIST;
- int a, b;
-};
-[...]
-```
-
-The structure is composed of 2 integers, the real data, and the
-``EINA_INLIST`` type which is composed of 3 pointers defining the inline list
-structure:
- * ``Eina_Inlist * next``: next node
- * ``Eina_Inlist * prev``: previous node
- * ``Eina_Inlist * last``: last node
-
-__**2**__. To create the inlist nodes, allocate the memory and use the
-``eina_inlist_append()`` function:
-
- * The first parameter is the existing list head or NULL to create a new
list. \\ \\ The following example passes NULL to create a new list.
- * The second parameter is the new list node, and it must not be NULL. \\ \\
You must use the ``EINA_INLIST_GET()`` macro to get the inlist object of the
datastruct.
-
-```c
-[...]
-struct my_struct *d, *cur;
-Eina_Inlist *list, *itr, *tmp;
-
-d = malloc(sizeof(*d));
-d->a = 1;
-d->b = 10;
-
-list = eina_inlist_append(NULL, EINA_INLIST_GET(d));
-[...]
-```
-
-Repeat this operation for every new node:
-
-```c
-[...]
-d = malloc(sizeof(*d));
-d->a = 2;
-d->b = 20;
-list = eina_inlist_append(list, EINA_INLIST_GET(d));
-[...]
-```
-
-__**3**__. To add data to the inline list:
-
- * Put data at the end of the inline list with the ``eina_inlist_prepend()``
function:
-
-```c
-[...]
-d = malloc(sizeof(*d));
-d->a = 3;
-d->b = 30;
-list = eina_inlist_prepend(list, EINA_INLIST_GET(d));
-[...]
-```
-
- * Add a node before or after a given node with the
``eina_inlist_prepend_relative()`` and ``eina_inlist_append_relative()``
functions. \\ \\ In both functions, the first parameter is the target list, the
second is the element you want to add, and the last is the reference element to
place data after (in this case). Similarly as in a regular ``Eina_List``,
everything is a list, so the last parameter is an ``Eina_Inlist`` typed
variable.
-
-```c
-[...]
-d = malloc(sizeof(*d));
-d->a = 4;
-d->b = 40;
-list = eina_inlist_append_relative(list, EINA_INLIST_GET(d), list);
-[...]
-```
-
-__**4**__. To sort and iterate an inline list, to find and move list elements,
and to perform other inline list operations, see the Inline List API.
-
-__**5**__. When the inline list is no longer needed, destroy it by looping
over the list to free each ``EINA_INLIST`` structure and the data using
allocated memory. Use the ``eina_inlist_remove()`` function on each node.
-
-In the following example, the ``EINA_INLIST_CONTAINER_GET()`` macro returns
-the container object of an inlist (the ``EINA_INLIST`` of ``my_struct``), and
-the list element is removed and the allocated memory of the container "object"
-is freed.
-
-```c
-[...]
-while (list)
- {
- struct my_struct *aux = EINA_INLIST_CONTAINER_GET(list, struct my_struct);
-
- // Remove the current list element
- list = eina_inlist_remove(list, list);
- free(aux);
- }
-[...]
-```
-
-### Further Reading ###
-
-[List
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__List__Group.html)
-: Functions that provide list management.
-
-[List Example
1](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_list_01_8c-example.html)
-: Example of list usage 1.
-
-[List Example
2](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_list_02_8c-example.html)
-: Example of list usage 2.
-
-[List Example
3](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_list_03_8c-example.html)
-: Example of list usage 3.
-
-[List Example
4](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_list_04_8c-example.html)
-: Example of list usage 4.
\ No newline at end of file
diff --git a/pages/eina-programming-guide/strings.md.txt
b/pages/eina-programming-guide/strings.md.txt
deleted file mode 100644
index 56024b9a..00000000
--- a/pages/eina-programming-guide/strings.md.txt
+++ /dev/null
@@ -1,175 +0,0 @@
----
-~~Title: Strings~~
----
-
-# Strings #
-
-You can create and manipulate strings in Enlightenment using two Eina types:
Stringshares and String Buffers.
-
-## Stringshares ##
-
-The ``Eina_Stringshare`` data type functions allow you to store a single copy
of a string and use it in multiple places throughout your program. This way you
can save a lot of strings with less memory. It improves string creation and
destruction speed, reduces memory use, and decreases memory fragmentation.
-
-With this data type you can reduce the number of duplicated strings kept in
memory. It is common for the same strings to be dynamically allocated
repeatedly between applications and libraries, especially in circumstances
where you can have multiple copies of a structure that allocates the string.
Rather than duplicating and freeing these strings, request a read-only pointer
-to an existing string and only incur the overhead of a hash lookup. This can
sound like micro-optimizing, but profiling has shown that this can have a
significant impact as the number of copies grows.
-
-### Managing Stringshares ###
-
-To create a stringshare, declare a string variable and call the
``eina_stringshare_add()`` function:
-
-```c
-[...]
-const char *mystr;
-const char *prologue = "Enlightenment is not just a window manager for
Linux/X11 and others"
-
-mystr = eina_stringshare_add(prologue);
-[...]
-```
-> **NOTE:**
-> ``[...]`` in a Code Block indicates there will usually be code above and
below the shown snippet, but that it has been excluded for the sake of brevity.
There is no need to type ``[...]`` into your program.
-
-To retrieve or modify the string data, retrieve a string for use in a program
from a format string using the ``eina_stringshare_printf()`` function. If you
have a "format" string to pass to a function like ``printf``, you can store it
as a stringshare as well. The following example produces "1 desktop manager to
rule them all".
-
-```c
-[...]
-const char *myfmtstr = "%d desktop manager to rule them all";
-const char *str;
-
-str = eina_stringshare_printf(myfmtstr, 1);
-
-print(str)
-[...]
-```
-
-You can replace the value of a stringshare with the
``eina_stringshare_replace()`` function. Pass the pointer address and the new
value to the function.
-
-```c
-[...]
-eina_stringshare_replace(&str,"One desktop manager to rule them all");
-[...]
-```
-
-You can retrieve the length of the stringshare value with the
``eina_stringshare_strlen()`` function.
-
-```c
-[...]
- printf("length: %d\n", eina_stringshare_strlen(str));
-[...]
-```
-
-When the string is no longer needed, delete it using the
``eina_stringshare_del()`` function:
-
-```c
-[...]
-eina_stringshare_del(mystr);
-[...]
-```
-
-## String Buffer ##
-
-The string buffer data type is designed to be a mutable string, allowing you
to append, prepend or insert a string to a buffer. It allows easy handling of
buffers in your applications.
-
-### Managing string buffer ###
-
-First initialize the ``Eina_Strbuf`` instance and create the buffer:
-
-```c
-[...]
-Eina_Strbuf *buf;
-mybuffer = eina_strbuf_new();
-[...]
-```
-You can append basic strings to the buffer using the ``eina_strbuf_append()``
function:
-
-```c
-[...]
-eina_strbuf_append(mybuffer, "This is my string.");
-[...]
-```
-
-To append 1 character to your buffer, use the ``eina_strbuf_append_char()``
function. You can also append a sized string to the buffer using the
``eina_strbuf_append_length()`` function:
-
-```c
-[...]
-eina_strbuf_append_length(mybuffer, "Buffe", 5);
-eina_strbuf_append_char(mybuffer, 'r');
-[...]
-```
-
-To handle "printf" format strings, use the ``eina_strbuf_append_printf()``
function to add formatted strings to the buffer:
-
-```c
-[...]
-eina_strbuf_append_printf(buf, "%s%c", "buffe", 'r');
-[...]
-```
-
-To remove characters from one position to another, use the
``eina_strbuf_remove()`` function. The first parameter is the buffer, the
second is the start position of the characters you want to delete, and the last
the end position. \\ This example removes the first 19 characters of the buffer:
-
-```c
-[...]
-eina_strbuf_remove(buf, 0, 18);
-[...]
-```
-
-To replace characters use ``eina_strbuf_replace()`` to replace a specific
occurrence of a given string in the buffer with another string. Use
``eina_strbuf_replace_all()`` to replace all occurrences of a given string in
the buffer with another string.
-
-```c
-[...]
-eina_strbuf_append(mybuffer, "buffer buffer buffer");
-
-// Replacing one occurrence of "buffer" by "B-U-F-F-E-R"
-eina_strbuf_replace(mybuffer, "buffer", "B-U-F-F-E-R", 1);
-
-// Replacing all the occurrences of "buffer" by "B-U-F-F-E-R"
-eina_strbuf_replace_all(mybuffer, "buffer", "B-U-F-F-E-R");
-
-// Replacing all the occurrences of "B-U-F-F-E-R" by "Buffer"
-eina_strbuf_replace_all(mybuffer, "B-U-F-F-E-R", "Buffer");
-[...]
-```
-
-To insert a string at the specified position, use the ``eina_strbuf_insert()``
function. Use the ``eina_strbuf_insert_printf()`` function with formatted
strings.
-
-
-```c
-[...]
-eina_strbuf_insert(mybuffer, "More buffer", 10);
-
-// Using eina_strbuf_length_get to get the buffer length
-eina_strbuf_insert_printf(buf, " %s: %d", 6, "length",
eina_strbuf_length_get(buf));
-[...]
-```
-
-To get the complete length of the string and the buffer, use the
``eina_strbuf_string_get()`` and ``eina_strbuf_length_get()`` functions:
-
-```c
-[...]
-printf("%s : %d\n", eina_strbuf_string_get(mybuffer),
eina_strbuf_length_get(buf));
-[...]
-```
-
-When no longer needed, free the buffer with the ``eina_strbuf_free()``
function. You can also free the content of ``Eina_Strbuf`` without freeing the
buffer itself using the ``eina_strbuf_string_free()`` function.
-
-```c
-[...]
-eina_strbuf_free(mybuffer);
-[...]
-```
-
-## Further Reading ##
-
-[String
Example](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_str_01_8c-example.html)
-: Example code using Eina strings.
-
-[Stringshare
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__Stringshare__Group.html)
-: The functions that allow you to store a single copy of a string, and use
it in multiple places throughout your program.
-
-[Stringshare
Example](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_stringshare_01_8c-example.html)
-: Example code showing how to use Stringshares.
-
-[String Buffer
API](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/group__Eina__String__Buffer__Group.html)
-: The functions that provide string buffers management.
-
-[String Buffer
Example](https://build.enlightenment.org/job/nightly_efl_gcc_x86_64/lastSuccessfulBuild/artifact/doc/html/eina_strbuf_01_8c-example.html)
-: Example code showing how to use String Buffers.
\ No newline at end of file
--
