merge: and the eina examples

SVN revision: 76715

54 files changed, 4947 insertions, 2 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 24ceadb561..529892093b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,8 +1,8 @@
 MAINTAINERCLEANFILES = Makefile.in
 
-SUBDIRS = lib include modules bin scripts benchmarks tests
+SUBDIRS = lib include modules bin scripts benchmarks tests examples
 
-.PHONY: benchmark benchmark-e17
+.PHONY: benchmark benchmark-e17 examples
 
 benchmark:
         @make -C lib
@@ -11,3 +11,10 @@ benchmark:
 benchmark-e17:
         @make -C lib
         @$(MAKE) -C benchmarks benchmark-e17
+
+examples:
+        @make -C lib
+        @$(MAKE) -C examples examples
+
+install-examples:
+        @$(MAKE) -C examples install-examples
diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am
new file mode 100644
index 0000000000..d6fbe3e3fe
--- /dev/null
+++ b/src/examples/Makefile.am
@@ -0,0 +1,9 @@
+MAINTAINERCLEANFILES = Makefile.in
+
+SUBDIRS = eina
+
+examples:
+        @$(MAKE) -C eina examples
+
+install-examples:
+        @$(MAKE) -C eina install-examples
\ No newline at end of file
diff --git a/src/examples/eina/Makefile.am b/src/examples/eina/Makefile.am
new file mode 100644
index 0000000000..4656e47241
--- /dev/null
+++ b/src/examples/eina/Makefile.am
@@ -0,0 +1,120 @@
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I. \
+-I$(top_srcdir)/src/include/eina \
+-I$(top_builddir)/src/include/eina
+
+LDADD = $(top_builddir)/src/lib/eina/libeina.la
+
+SRCS = \
+eina_accessor_01.c \
+eina_array_01.c \
+eina_array_02.c \
+eina_error_01.c \
+eina_file_01.c \
+eina_hash_01.c \
+eina_hash_02.c \
+eina_hash_03.c \
+eina_hash_04.c \
+eina_hash_05.c \
+eina_hash_06.c \
+eina_hash_07.c \
+eina_hash_08.c \
+eina_iterator_01.c \
+eina_list_01.c \
+eina_list_02.c \
+eina_list_03.c \
+eina_list_04.c \
+eina_log_01.c \
+eina_log_02.c \
+eina_log_03.c \
+eina_inlist_01.c \
+eina_inlist_02.c \
+eina_inlist_03.c \
+eina_str_01.c \
+eina_strbuf_01.c \
+eina_stringshare_01.c \
+eina_tiler_01.c \
+eina_simple_xml_parser_01.c \
+eina_value_01.c \
+eina_value_02.c \
+eina_value_03.c \
+eina_inarray_01.c \
+eina_inarray_02.c
+#eina_magic_01.c \
+#eina_model_01.c \
+#eina_model_02.c \
+#eina_model_03.c
+
+EXTRA_PROGRAMS = \
+eina_accessor_01 \
+eina_array_01 \
+eina_array_02 \
+eina_error_01 \
+eina_file_01 \
+eina_hash_01 \
+eina_hash_02 \
+eina_hash_03 \
+eina_hash_04 \
+eina_hash_05 \
+eina_hash_06 \
+eina_hash_07 \
+eina_hash_08 \
+eina_iterator_01 \
+eina_list_01 \
+eina_list_02 \
+eina_list_03 \
+eina_list_04 \
+eina_log_01 \
+eina_log_02 \
+eina_log_03 \
+eina_inlist_01 \
+eina_inlist_02 \
+eina_inlist_03 \
+eina_str_01 \
+eina_strbuf_01 \
+eina_stringshare_01 \
+eina_magic_01 \
+eina_simple_xml_parser_01 \
+eina_value_01 \
+eina_value_02 \
+eina_value_03 \
+eina_inarray_01 \
+eina_inarray_02
+#eina_model_01 \
+#eina_model_02 \
+#eina_model_03 \
+#eina_model_04
+
+#eina_model_04_SOURCES = \
+#eina_model_04_animal.c \
+#eina_model_04_child.c \
+#eina_model_04_human.c \
+#eina_model_04_main.c \
+#eina_model_04_parrot.c \
+#eina_model_04_whistler.c \
+#eina_model_04_animal.h \
+#eina_model_04_child.h \
+#eina_model_04_human.h \
+#eina_model_04_parrot.h \
+#eina_model_04_whistler.h
+
+if BUILD_TILER_EXAMPLE
+AM_CPPFLAGS += @ECORE_EVAS_CFLAGS@
+EXTRA_PROGRAMS += eina_tiler_01
+eina_tiler_01_LDADD = $(top_builddir)/src/lib/eina/libeina.la @ECORE_EVAS_LIBS@
+endif
+
+examples: $(EXTRA_PROGRAMS)
+
+install-examples:
+        mkdir -p $(pkgdatadir)/examples
+        $(install_sh_DATA) -c $(SRCS) $(pkgdatadir)/examples
+
+unsinstall-local:
+        for f in $(SRCS) ; do \
+          rm -f $(pkgdatadir)/examples/$$f ; \
+        done
+
+EXTRA_DIST = addr_book.txt chat.xml
diff --git a/src/examples/eina/addr_book.txt b/src/examples/eina/addr_book.txt
new file mode 100644
index 0000000000..43abc44452
--- /dev/null
+++ b/src/examples/eina/addr_book.txt
@@ -0,0 +1,7 @@
+Kara Thrace     starbuck@bsg.com
+Sharon Valerii  boomer@bsg.com
+Sharon Aghaton  athena@bsg.com
+Karl Aghaton    helo@bsg.com
+Louanne Katraine        kat@bsg.com
+
+Lee Adama       apolo@bsg.com
diff --git a/src/examples/eina/chat.xml b/src/examples/eina/chat.xml
new file mode 100644
index 0000000000..140269c717
--- /dev/null
+++ b/src/examples/eina/chat.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE board SYSTEM "tp-0.1.dtd">
+<board site="http://linuxfr.org/">
+  <post id="3211">
+    <login>houplaboom</login>
+    <message>Is this an XML test?</message>
+  </post>
+  <post id="3212">
+    <login>fredx</login>
+    <message>I'm seeing bald people.</message>
+  </post>
+  <post id="3213">
+    <login>NedFlanders</login>
+    <message>Don't call him!</message>
+  </post>
+  <post id="3214">
+    <login>Single</login>
+    <message>I'm not bald!</message>
+  </post>
+  <post id="3215">
+    <login>ngc891</login>
+    <message>It was an XML test.</message>
+  </post>
+</board>
diff --git a/src/examples/eina/eina_accessor_01.c b/src/examples/eina/eina_accessor_01.c
new file mode 100644
index 0000000000..da413c6e72
--- /dev/null
+++ b/src/examples/eina/eina_accessor_01.c
@@ -0,0 +1,55 @@
+//Compile with:
+//gcc -g eina_accessor_01.c -o eina_accessor_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   const char *strings[] = {
+      "even", "odd", "even", "odd", "even", "odd", "even", "odd", "even", "odd"
+   };
+   const char *more_strings[] = {
+      "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+   };
+   Eina_Array *array;
+   Eina_List *list = NULL;
+   Eina_Accessor *acc;
+   unsigned short int i;
+   void *data;
+
+   eina_init();
+
+   array = eina_array_new(10);
+
+   for (i = 0; i < 10; i++)
+     {
+        eina_array_push(array, strings[i]);
+        list = eina_list_append(list, more_strings[i]);
+     }
+
+   acc = eina_array_accessor_new(array);
+   for(i = 1; i < 10; i += 2)
+     {
+        eina_accessor_data_get(acc, i, &data);
+        printf("%s\n", (const char *)data);
+     }
+   eina_accessor_free(acc);
+   eina_array_free(array);
+
+   acc = eina_list_accessor_new(list);
+   for(i = 1; i < 10; i += 2)
+     {
+        eina_accessor_data_get(acc, i, &data);
+        printf("%s\n", (const char *)data);
+     }
+
+   eina_list_free(eina_accessor_container_get(acc));
+   eina_accessor_free(acc);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_array_01.c b/src/examples/eina/eina_array_01.c
new file mode 100644
index 0000000000..43a332d87d
--- /dev/null
+++ b/src/examples/eina/eina_array_01.c
@@ -0,0 +1,51 @@
+//Compile with:
+//gcc -g eina_array_01.c -o eina_array_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+
+#include <Eina.h>
+
+static Eina_Bool
+_print(const void *container, void *data, void *fdata)
+{
+  printf("%s\n", (char *)data);
+   return EINA_TRUE;
+}
+
+int
+main(int argc, char **argv)
+{
+   const char* strings[] = {
+      "helo", "hera", "starbuck", "kat", "boomer",
+      "hotdog", "longshot", "jammer", "crashdown", "hardball",
+      "duck", "racetrack", "apolo", "husker", "freaker",
+      "skulls", "bulldog", "flat top", "hammerhead", "gonzo"
+   };
+   Eina_Array *array;
+   Eina_Array_Iterator iterator;
+   char *item;
+   unsigned int i;
+
+   eina_init();
+
+   array = eina_array_new(10);
+   eina_array_step_set(array, sizeof(*array), 20);
+
+   for (i = 0; i < 20; i++)
+     eina_array_push(array, strdup(strings[i]));
+
+   printf("array count: %d\n", eina_array_count(array));
+   eina_array_foreach(array, _print, NULL);
+
+   printf("Top gun: %s\n", (char*)eina_array_data_get(array, 2));
+
+   while (eina_array_count(array))
+     free(eina_array_pop(array));
+
+   eina_array_free(array);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_array_02.c b/src/examples/eina/eina_array_02.c
new file mode 100644
index 0000000000..6b2903b21a
--- /dev/null
+++ b/src/examples/eina/eina_array_02.c
@@ -0,0 +1,57 @@
+//Compile with:
+//gcc -g eina_array_02.c -o eina_array_02 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+
+#include <Eina.h>
+
+Eina_Bool keep(void *data, void *gdata)
+{
+   if (strlen((const char*)data) <= 5)
+      return EINA_TRUE;
+   return EINA_FALSE;
+}
+
+int
+main(int argc, char **argv)
+{
+   const char* strs[] = {
+      "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
+      "ten", "eleven", "twelve", "thirteen", "fourtenn", "fifteen", "sixteen",
+      "seventeen", "eighteen", "nineteen", "twenty"
+   };
+   const char* strings[] = {
+      "helo", "hera", "starbuck", "kat", "boomer",
+      "hotdog", "longshot", "jammer", "crashdown", "hardball",
+      "duck", "racetrack", "apolo", "husker", "freaker",
+      "skulls", "bulldog", "flat top", "hammerhead", "gonzo"
+   };
+   Eina_Array *array;
+   Eina_Array_Iterator iterator;
+   const char *item;
+   unsigned int i;
+
+   eina_init();
+
+   array = eina_array_new(10);
+
+   for (i = 0; i < 20; i++)
+     eina_array_push(array, strs[i]);
+
+   eina_array_clean(array);
+   for (i = 0; i < 20; i++)
+     eina_array_push(array, strings[i]);
+
+   eina_array_data_set(array, 17, "flattop");
+
+   eina_array_remove(array, keep, NULL);
+   EINA_ARRAY_ITER_NEXT(array, i, item, iterator)
+     printf("item #%d: %s\n", i, item);
+
+   eina_array_free(array);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_error_01.c b/src/examples/eina/eina_error_01.c
new file mode 100644
index 0000000000..25a8ab25f8
--- /dev/null
+++ b/src/examples/eina/eina_error_01.c
@@ -0,0 +1,81 @@
+//Compile with:
+//gcc -g eina_error_01.c -o eina_error_01 `pkg-config --cflags --libs eina`
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <eina_main.h>
+#include <eina_error.h>
+
+Eina_Error MY_ERROR_NEGATIVE;
+Eina_Error MY_ERROR_NULL;
+
+void *data_new()
+{
+   eina_error_set(0);
+
+   eina_error_set(MY_ERROR_NULL);
+   return NULL;
+}
+
+int test(int n)
+{
+   eina_error_set(0);
+
+   if (n < 0)
+     {
+        eina_error_set(MY_ERROR_NEGATIVE);
+        return 0;
+     }
+
+   return 1;
+}
+
+int main(void)
+{
+   void *data;
+
+   if (!eina_init())
+     {
+        printf ("Error during the initialization of eina_error module\n");
+        return EXIT_FAILURE;
+     }
+
+   MY_ERROR_NEGATIVE = eina_error_msg_static_register("Negative number");
+   MY_ERROR_NULL = eina_error_msg_static_register("NULL pointer");
+
+   data = data_new();
+   if (!data)
+     {
+        Eina_Error err;
+
+        err = eina_error_get();
+        if (err)
+           printf("Error during memory allocation: %s\n",
+                  eina_error_msg_get(err));
+     }
+
+   if (!test(0))
+     {
+        Eina_Error err;
+
+        err = eina_error_get();
+        if (err)
+           printf("Error during test function: %s\n",
+                  eina_error_msg_get(err));
+     }
+
+   if (!test(-1))
+     {
+        Eina_Error err;
+
+        err = eina_error_get();
+        if (err)
+           printf("Error during test function: %s\n",
+                  eina_error_msg_get(err));
+     }
+
+   eina_shutdown();
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/examples/eina/eina_file_01.c b/src/examples/eina/eina_file_01.c
new file mode 100644
index 0000000000..2c945b3ad7
--- /dev/null
+++ b/src/examples/eina/eina_file_01.c
@@ -0,0 +1,45 @@
+//Compile with:
+//gcc -g eina_file_01.c -o eina_file_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <Eina.h>
+
+static void
+_print_cb(const char *name, const char *path, void *data)
+{
+   printf("file %s in %s\n", name, path);
+}
+
+int
+main(int argc, char **argv)
+{
+   Eina_Iterator *it;
+   const char *f_name;
+   const Eina_File_Direct_Info *f_info;
+
+   eina_init();
+
+   eina_file_dir_list("/home/", EINA_FALSE, _print_cb, NULL);
+
+   it = eina_file_ls("/home/");
+   EINA_ITERATOR_FOREACH(it, f_name)
+     {
+        printf("%s\n", f_name);
+        eina_stringshare_del(f_name);
+     }
+   eina_iterator_free(it);
+
+   it = eina_file_stat_ls("/home/");
+   EINA_ITERATOR_FOREACH(it, f_info)
+     printf("%s if of type %d\n", f_info->path, f_info->type);
+   eina_iterator_free(it);
+
+   it = eina_file_direct_ls("/home/");
+   EINA_ITERATOR_FOREACH(it, f_info)
+     printf("%s if of type %d\n", f_info->path, f_info->type);
+   eina_iterator_free(it);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_hash_01.c b/src/examples/eina/eina_hash_01.c
new file mode 100644
index 0000000000..16418feeac
--- /dev/null
+++ b/src/examples/eina/eina_hash_01.c
@@ -0,0 +1,198 @@
+//Compile with:
+//gcc -g eina_hash_01.c -o eina_hash_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const char *name = key;
+   const char *number = data;
+   printf("%s: %s\n", name, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   const char *entry_name = "Heitor Villa-Lobos";
+   char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_string_superfast_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        eina_hash_add(phone_book, _start_entries[i].name,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, entry_name);
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Name: %s\n", entry_name);
+        printf("Number: %s\n\n", phone);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, entry_name, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   phone = eina_hash_modify(phone_book, "Richard Georg Strauss",
+                            strdup("+23 45 111-11111"));
+   free(phone);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 01 234-56789"));
+   if (!phone)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting phone for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old phone for Raul Seixas was %s\n", phone);
+        free(phone);
+     }
+
+   printf("\n");
+
+   // Now change the phone number
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 02 222-22222"));
+   if (phone)
+     {
+        printf("Changing phone for Raul Seixas to +55 02 222-22222. ");
+        printf("Old phone was %s\n", phone);
+        free(phone);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing phone for Raul Seixas\n");
+        else
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names and associated numbers.
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("List of phones:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        const char *name = t->key;
+        const char *number = t->data;
+        printf("%s: %s\n", name, number);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of names in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *name = data;
+        printf("%s\n", name);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (numbers)
+   printf("List of numbers in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *number = data;
+        printf("%s\n", number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   eina_hash_move(phone_book, "Raul Seixas", "Alceu Valenca");
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_02.c b/src/examples/eina/eina_hash_02.c
new file mode 100644
index 0000000000..7baec93ea2
--- /dev/null
+++ b/src/examples/eina/eina_hash_02.c
@@ -0,0 +1,147 @@
+//Compile with:
+//gcc -g eina_hash_02.c -o eina_hash_02 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - Two more types of hash
+ *
+ * This example demonstrate two other types of hash in action - using
+ * eina_hash_stringshared_new and eina_hash_new.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with string
+ * keys, exactly the same as the other example.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+};
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static void
+_phone_book_stringshared_free_cb(void *data)
+{
+   Phone_Entry *e = data;
+   eina_stringshare_del(e->name);
+   eina_stringshare_del(e->number);
+   free(e);
+}
+
+static Eina_Bool
+_phone_book_stringshared_foreach_cb(const Eina_Hash *phone_book,
+                                    const void *key, void *data, void *fdata)
+{
+   Phone_Entry *e = data;
+   const char *name = e->name; // e->name == key
+   const char *number = e->number;
+   printf("%s: %s\n", name, number);
+
+   return EINA_TRUE;
+}
+
+static void
+example_hash_stringshared(void)
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+
+   // Create the hash as before
+   phone_book = eina_hash_stringshared_new(_phone_book_stringshared_free_cb);
+
+   // Add initial entries to our hash, using direct_add
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        Phone_Entry *e = malloc(sizeof(Phone_Entry));
+        e->name = eina_stringshare_add(_start_entries[i].name);
+        e->number = eina_stringshare_add(_start_entries[i].number);
+        // Since we are storing the key (name) in our struct, we can use
+        // eina_hash_direct_add. It could be used in the previous example
+        // too, since each key is already stored in the _start_entries
+        // static array, but we started it with the default add function.
+        eina_hash_direct_add(phone_book, e->name, e);
+     }
+
+   // Iterate over the elements
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_stringshared_foreach_cb, NULL);
+   printf("\n");
+
+   eina_hash_free(phone_book);
+}
+
+static unsigned int
+_phone_book_string_key_length(const char *key)
+{
+   if (!key)
+      return 0;
+
+   return (int)strlen(key) + 1;
+}
+
+static int
+_phone_book_string_key_cmp(const char *key1, int key1_length,
+                     const char *key2, int key2_length)
+{
+   return strcmp(key1, key2);
+}
+
+static void
+example_hash_big(void)
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   const char *phone;
+
+   // Create the same hash as used in eina_hash_01.c, but
+   // use 1024 (2 ^ 10) buckets.
+   phone_book = eina_hash_new(EINA_KEY_LENGTH(_phone_book_string_key_length),
+                              EINA_KEY_CMP(_phone_book_string_key_cmp),
+                              EINA_KEY_HASH(eina_hash_superfast),
+                              _phone_entry_free_cb,
+                              10);
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        eina_hash_add(phone_book, _start_entries[i].name,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, "Heitor Villa-Lobos");
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Name: Heitor Villa-Lobos\n");
+        printf("Number: %s\n\n", phone);
+     }
+
+   eina_hash_free(phone_book);
+}
+
+int
+main(int argc, const char *argv[])
+{
+   eina_init();
+
+   example_hash_stringshared();
+   example_hash_big();
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_03.c b/src/examples/eina/eina_hash_03.c
new file mode 100644
index 0000000000..ba543d4179
--- /dev/null
+++ b/src/examples/eina/eina_hash_03.c
@@ -0,0 +1,198 @@
+//Compile with:
+//gcc -g eina_hash_03.c -o eina_hash_03 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const char *name = key;
+   const char *number = data;
+   printf("%s: %s\n", name, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   const char *entry_name = "Heitor Villa-Lobos";
+   char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_string_small_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        eina_hash_add(phone_book, _start_entries[i].name,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, entry_name);
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Name: %s\n", entry_name);
+        printf("Number: %s\n\n", phone);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, entry_name, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   phone = eina_hash_modify(phone_book, "Richard Georg Strauss",
+                            strdup("+23 45 111-11111"));
+   free(phone);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 01 234-56789"));
+   if (!phone)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting phone for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old phone for Raul Seixas was %s\n", phone);
+        free(phone);
+     }
+
+   printf("\n");
+
+   // Now change the phone number
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 02 222-22222"));
+   if (phone)
+     {
+        printf("Changing phone for Raul Seixas to +55 02 222-22222. ");
+        printf("Old phone was %s\n", phone);
+        free(phone);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing phone for Raul Seixas\n");
+        else
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names and associated numbers.
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("List of phones:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        const char *name = t->key;
+        const char *number = t->data;
+        printf("%s: %s\n", name, number);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of names in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *name = data;
+        printf("%s\n", name);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (numbers)
+   printf("List of numbers in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *number = data;
+        printf("%s\n", number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   eina_hash_move(phone_book, "Raul Seixas", "Alceu Valenca");
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_04.c b/src/examples/eina/eina_hash_04.c
new file mode 100644
index 0000000000..da73e04b1b
--- /dev/null
+++ b/src/examples/eina/eina_hash_04.c
@@ -0,0 +1,198 @@
+//Compile with:
+//gcc -g eina_hash_04.c -o eina_hash_04 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const char *name = key;
+   const char *number = data;
+   printf("%s: %s\n", name, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   const char *entry_name = "Heitor Villa-Lobos";
+   char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_string_djb2_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        eina_hash_add(phone_book, _start_entries[i].name,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, entry_name);
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Name: %s\n", entry_name);
+        printf("Number: %s\n\n", phone);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, entry_name, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   phone = eina_hash_modify(phone_book, "Richard Georg Strauss",
+                            strdup("+23 45 111-11111"));
+   free(phone);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 01 234-56789"));
+   if (!phone)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting phone for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old phone for Raul Seixas was %s\n", phone);
+        free(phone);
+     }
+
+   printf("\n");
+
+   // Now change the phone number
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, "Raul Seixas",
+                         strdup("+55 02 222-22222"));
+   if (phone)
+     {
+        printf("Changing phone for Raul Seixas to +55 02 222-22222. ");
+        printf("Old phone was %s\n", phone);
+        free(phone);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing phone for Raul Seixas\n");
+        else
+          {
+             printf("No previous phone found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names and associated numbers.
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("List of phones:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        const char *name = t->key;
+        const char *number = t->data;
+        printf("%s: %s\n", name, number);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of names in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *name = data;
+        printf("%s\n", name);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (numbers)
+   printf("List of numbers in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *number = data;
+        printf("%s\n", number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   eina_hash_move(phone_book, "Raul Seixas", "Alceu Valenca");
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_05.c b/src/examples/eina/eina_hash_05.c
new file mode 100644
index 0000000000..6666ce2d3d
--- /dev/null
+++ b/src/examples/eina/eina_hash_05.c
@@ -0,0 +1,201 @@
+//Compile with:
+//gcc -g eina_hash_05.c -o eina_hash_05 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     int32_t id; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { 1, "+01 23 456-78910" },
+       { 2, "+12 34 567-89101" },
+       { 3, "+23 45 678-91012" },
+       { 4, "+34 56 789-10123" },
+       { -1, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const int32_t *id = key;
+   const char *number = data;
+   printf("%d: %s\n", *id, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   int32_t entry_id = 4;
+   char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_int32_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].id != -1; i++)
+     {
+        eina_hash_add(phone_book, &_start_entries[i].id,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, &entry_id);
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Id: %d\n", entry_id);
+        printf("Number: %s\n\n", phone);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, &entry_id, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   int32_t id3 = 3;
+   phone = eina_hash_modify(phone_book, &id3,
+                            strdup("+23 45 111-11111"));
+   free(phone);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   int32_t id5 = 5;
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, &id5,
+                         strdup("+55 01 234-56789"));
+   if (!phone)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous phone found for id5. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting phone for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old phone for id5 was %s\n", phone);
+        free(phone);
+     }
+
+   printf("\n");
+
+   // Now change the phone number
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, &id5,
+                         strdup("+55 02 222-22222"));
+   if (phone)
+     {
+        printf("Changing phone for id5 to +55 02 222-22222. ");
+        printf("Old phone was %s\n", phone);
+        free(phone);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing phone for id5\n");
+        else
+          {
+             printf("No previous phone found for id5. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names and associated numbers.
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("List of phones:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        const int32_t *id = t->key;
+        const char *number = t->data;
+        printf("%d: %s\n", *id, number);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of ids in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const int32_t *id = data;
+        printf("%d\n", *id);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (numbers)
+   printf("List of numbers in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *number = data;
+        printf("%s\n", number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   int32_t id6 = 6;
+   eina_hash_move(phone_book, &id5, &id6);
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_06.c b/src/examples/eina/eina_hash_06.c
new file mode 100644
index 0000000000..a7a5504d2a
--- /dev/null
+++ b/src/examples/eina/eina_hash_06.c
@@ -0,0 +1,201 @@
+//Compile with:
+//gcc -g eina_hash_06.c -o eina_hash_06 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     int64_t id; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { 1, "+01 23 456-78910" },
+       { 2, "+12 34 567-89101" },
+       { 3, "+23 45 678-91012" },
+       { 4, "+34 56 789-10123" },
+       { -1, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const int64_t *id = key;
+   const char *number = data;
+   printf("%lld: %s\n", *id, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   int64_t entry_id = 4;
+   char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_int64_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].id != -1; i++)
+     {
+        eina_hash_add(phone_book, &_start_entries[i].id,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Look for a specific entry and get its phone number
+   phone = eina_hash_find(phone_book, &entry_id);
+   if (phone)
+     {
+        printf("Printing entry.\n");
+        printf("Id: %lld\n", entry_id);
+        printf("Number: %s\n\n", phone);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, &entry_id, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   int64_t id3 = 3;
+   phone = eina_hash_modify(phone_book, &id3,
+                            strdup("+23 45 111-11111"));
+   free(phone);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   int64_t id5 = 5;
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, &id5,
+                         strdup("+55 01 234-56789"));
+   if (!phone)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous phone found for id5. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting phone for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old phone for id5 was %s\n", phone);
+        free(phone);
+     }
+
+   printf("\n");
+
+   // Now change the phone number
+   eina_error_set(0);
+   phone = eina_hash_set(phone_book, &id5,
+                         strdup("+55 02 222-22222"));
+   if (phone)
+     {
+        printf("Changing phone for id5 to +55 02 222-22222. ");
+        printf("Old phone was %s\n", phone);
+        free(phone);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing phone for id5\n");
+        else
+          {
+             printf("No previous phone found for id5. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names and associated numbers.
+   printf("List of phones:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("List of phones:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        const int64_t *id = t->key;
+        const char *number = t->data;
+        printf("%lld: %s\n", *id, number);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of ids in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const int64_t *id = data;
+        printf("%lld\n", *id);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (numbers)
+   printf("List of numbers in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        const char *number = data;
+        printf("%s\n", number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   int64_t id6 = 6;
+   eina_hash_move(phone_book, &id5, &id6);
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_07.c b/src/examples/eina/eina_hash_07.c
new file mode 100644
index 0000000000..1464e6b417
--- /dev/null
+++ b/src/examples/eina/eina_hash_07.c
@@ -0,0 +1,222 @@
+//Compile with:
+//gcc -g eina_hash_07.c -o eina_hash_07 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+}; // _start_entries
+
+static const char *_nicknames[] = {
+       "mozzart",
+       "betho",
+       "george",
+       "hector",
+       NULL
+};
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   Phone_Entry **pe = (Phone_Entry **)key;
+   const char *nick = data;
+   printf("%s: %s, nick=%s\n", (*pe)->name, (*pe)->number, nick);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   Phone_Entry *entry_vl = &_start_entries[3];
+   Phone_Entry *p = NULL;
+   char *nick = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_pointer_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        p = &_start_entries[i];
+        eina_hash_add(phone_book, &p,
+                      strdup(_nicknames[i]));
+     }
+   printf("Phonebook:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Look for a specific entry and get its nickname
+   nick = eina_hash_find(phone_book, &entry_vl);
+   if (nick)
+     {
+        printf("Printing entry.\n");
+        printf("Name: %s\n", entry_vl->name);
+        printf("Number: %s\n", entry_vl->number);
+        printf("Nick: %s\n\n", nick);
+     }
+
+   // Delete this entry
+   r = eina_hash_del(phone_book, &entry_vl, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // Modify the pointer data of an entry and free the old one
+   p = &_start_entries[2];
+   nick = eina_hash_modify(phone_book, &p,
+                           strdup("el jorge"));
+   free(nick);
+
+   // Modify or add an entry to the hash with eina_hash_set
+   // Let's first add a new entry
+   eina_error_set(0);
+   Phone_Entry *p1 = malloc(sizeof(*p1));
+   p1->name = "Raul Seixas";
+   p1->number = "+55 01 234-56789";
+   nick = eina_hash_set(phone_book, &p1,
+                        strdup("raulzito"));
+   if (!nick)
+     {
+        Eina_Error err = eina_error_get();
+        if (!err)
+          {
+             printf("No previous nick found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+        else
+          printf("Error when setting nick for Raul Seixas\n");
+     }
+   else
+     {
+        printf("Old nick for Raul Seixas was %s\n", nick);
+        free(nick);
+     }
+
+   printf("\n");
+
+   // Now change the nick
+   eina_error_set(0);
+   nick = eina_hash_set(phone_book, &p1,
+                        strdup("raulzao"));
+   if (nick)
+     {
+        printf("Changing nick for Raul Seixas to raulzao. ");
+        printf("Old nick was %s\n", nick);
+        free(nick);
+     }
+   else
+     {
+        Eina_Error err = eina_error_get();
+        if (err)
+          printf("Error when changing nick for Raul Seixas\n");
+        else
+          {
+             printf("No previous nick found for Raul Seixas. ");
+             printf("Creating new entry.\n");
+          }
+     }
+
+   // There are many ways to iterate over our Phone book.
+   // First, iterate showing the names, phones and associated nicks.
+   printf("Phonebook:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Now iterate using an iterator
+   printf("Phonebook:\n");
+   it = eina_hash_iterator_tuple_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Eina_Hash_Tuple *t = data;
+        Phone_Entry **pe = (Phone_Entry **)t->key;
+        nick = t->data;
+        printf("%s: %s, nick=%s\n", (*pe)->name, (*pe)->number, nick);
+     }
+   eina_iterator_free(it); // Always free the iterator after its use
+   printf("\n");
+
+   // Just iterate over the keys (names)
+   printf("List of names/numbers in the phone book:\n");
+   it = eina_hash_iterator_key_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        Phone_Entry **pe = (Phone_Entry **)data;
+        printf("%s: %s\n", (*pe)->name, (*pe)->number);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Just iterate over the data (nicks)
+   printf("List of nicks in the phone book:\n");
+   it = eina_hash_iterator_data_new(phone_book);
+   while (eina_iterator_next(it, &data))
+     {
+        nick = data;
+        printf("%s\n", nick);
+     }
+   eina_iterator_free(it);
+   printf("\n");
+
+   // Check how many items are in the phone book
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Change the name (key) on an entry
+   Phone_Entry *p2 = malloc(sizeof(*p2));
+   p2->name = "Alceu Valenca";
+   p2->number = "000000000000";
+   eina_hash_move(phone_book, p1, p2);
+   printf("List of phones after change:\n");
+   eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
+   printf("\n");
+
+   // Empty the phone book, but don't destroy it
+   eina_hash_free_buckets(phone_book);
+   printf("There are %d items in the hash.\n\n",
+          eina_hash_population(phone_book));
+
+   // Phone book could still be used, but we are freeing it since we are
+   // done for now
+   eina_hash_free(phone_book);
+
+   free(p1);
+   free(p2);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_hash_08.c b/src/examples/eina/eina_hash_08.c
new file mode 100644
index 0000000000..ed45f7f90f
--- /dev/null
+++ b/src/examples/eina/eina_hash_08.c
@@ -0,0 +1,128 @@
+//Compile with:
+//gcc -g eina_hash_08.c -o eina_hash_08 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+/*
+ * Eina Hash - phonebook
+ *
+ * This example demonstrate the use of Eina Hash by implementing a phonebook
+ * that stores its contact data into the hash.
+ *
+ * It indexes the phone numbers by Contact Full Name, so it's a hash with
+ * string keys.
+ */
+
+struct _Phone_Entry {
+     const char *name; // Full name.
+     const char *number; // Phone number.
+};
+
+typedef struct _Phone_Entry Phone_Entry;
+
+static Phone_Entry _start_entries[] = {
+       { "Wolfgang Amadeus Mozart", "+01 23 456-78910" },
+       { "Ludwig van Beethoven", "+12 34 567-89101" },
+       { "Richard Georg Strauss", "+23 45 678-91012" },
+       { "Heitor Villa-Lobos", "+34 56 789-10123" },
+       { NULL, NULL }
+}; // _start_entries
+
+static void
+_phone_entry_free_cb(void *data)
+{
+   free(data);
+}
+
+static Eina_Bool
+_phone_book_foreach_cb(const Eina_Hash *phone_book, const void *key,
+                       void *data, void *fdata)
+{
+   const char *name = key;
+   const char *number = data;
+   printf("%s: %s\n", name, number);
+
+   // Return EINA_FALSE to stop this callback from being called
+   return EINA_TRUE;
+}
+
+int
+main(int argc, const char *argv[])
+{
+   Eina_Hash *phone_book = NULL;
+   int i;
+   const char *entry_name = "Heitor Villa-Lobos";
+   int entry_size;
+   const char *saved_entry_name = "Alceu Valenca";
+   int saved_entry_size = sizeof("Alceu Valenca");
+   const char *phone = NULL;
+   Eina_Bool r;
+   Eina_Iterator *it;
+   void *data;
+
+   eina_init();
+
+   phone_book = eina_hash_string_superfast_new(_phone_entry_free_cb);
+
+   // Add initial entries to our hash
+   for (i = 0; _start_entries[i].name != NULL; i++)
+     {
+        eina_hash_add(phone_book, _start_entries[i].name,
+                      strdup(_start_entries[i].number));
+     }
+
+   // Delete entries
+   r = eina_hash_del(phone_book, entry_name, NULL);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   int hash = eina_hash_superfast("Ludwig van Beethoven",
+                                  sizeof("Ludwig van Beethoven"));
+
+   r = eina_hash_del_by_key_hash(phone_book, "Ludwig van Beethoven",
+                                 sizeof("Ludwig van Beethoven"), hash);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   r = eina_hash_del_by_key(phone_book, "Richard Georg Strauss");
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // add entry by hash
+   entry_name = "Raul_Seixas";
+   entry_size = sizeof("Raul Seixas");
+   phone = strdup("+33 33 333-33333");
+   hash = eina_hash_superfast(entry_name, entry_size);
+   eina_hash_add_by_hash(phone_book, entry_name, entry_size, hash, phone);
+
+   // don't need to free 'phone' after the next del:
+   r = eina_hash_del_by_data(phone_book, phone);
+   printf("Hash entry successfully deleted? %d\n\n", r);
+
+   // add entry by hash directly - no copy of the key will be done
+   hash = eina_hash_superfast(saved_entry_name, saved_entry_size);
+   phone = strdup("+44 44 444-44444");
+   eina_hash_direct_add_by_hash(phone_book, saved_entry_name,
+                                saved_entry_size, hash, phone);
+
+   // find the added entry by its hash:
+   phone = eina_hash_find_by_hash(phone_book, saved_entry_name,
+                                  saved_entry_size, hash);
+   if (phone)
+     {
+        char *newphone = strdup("+55 55 555-55555");
+        phone = eina_hash_modify_by_hash(phone_book, saved_entry_name,
+                                         saved_entry_size, hash, newphone);
+        if (phone)
+          printf("changing phone to %s, old one was %s\n", newphone, phone);
+        else
+          printf("couldn't modify entry identified by %d\n", hash);
+     }
+   else
+     {
+        printf("couldn't find entry identified by %d\n", hash);
+     }
+
+   eina_hash_free(phone_book);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_inarray_01.c b/src/examples/eina/eina_inarray_01.c
new file mode 100644
index 0000000000..2809778993
--- /dev/null
+++ b/src/examples/eina/eina_inarray_01.c
@@ -0,0 +1,52 @@
+//Compile with:
+//gcc -g eina_inarray_01.c -o eina_inarray_01 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+
+int
+cmp(const void *a, const void *b)
+{
+   return *(int*)a > *(int*)b;
+}
+
+int main(int argc, char **argv)
+{
+   Eina_Inarray *iarr;
+   char ch, *ch2;
+   int a, *b;
+
+   eina_init();
+   iarr = eina_inarray_new(sizeof(char), 0);
+
+   ch = 'a';
+   eina_inarray_push(iarr, &ch);
+   ch = 'b';
+   eina_inarray_push(iarr, &ch);
+   ch = 'c';
+   eina_inarray_push(iarr, &ch);
+   ch = 'd';
+   eina_inarray_push(iarr, &ch);
+
+   printf("Inline array of chars:\n");
+   EINA_INARRAY_FOREACH(iarr, ch2)
+     printf("char: %c(pointer: %p)\n", *ch2, ch2);
+
+   eina_inarray_flush(iarr);
+   eina_inarray_step_set(iarr, sizeof(Eina_Inarray), sizeof(int), 4);
+
+   a = 97;
+   eina_inarray_push(iarr, &a);
+   a = 98;
+   eina_inarray_push(iarr, &a);
+   a = 100;
+   eina_inarray_push(iarr, &a);
+   a = 99;
+   eina_inarray_insert_sorted(iarr, &a, cmp);
+
+   printf("Inline array of integers with %d elements:\n", eina_inarray_count(iarr));
+   EINA_INARRAY_FOREACH(iarr, b)
+     printf("int: %d(pointer: %p)\n", *b, b);
+
+   eina_inarray_free(iarr);
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_inarray_02.c b/src/examples/eina/eina_inarray_02.c
new file mode 100644
index 0000000000..17c0667408
--- /dev/null
+++ b/src/examples/eina/eina_inarray_02.c
@@ -0,0 +1,33 @@
+//Compile with:
+//gcc -g eina_inarray_02.c -o eina_inarray_02 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   const char* strings[] = {
+      "helo", "hera", "starbuck", "kat", "boomer",
+      "hotdog", "longshot", "jammer", "crashdown", "hardball",
+      "duck", "racetrack", "apolo", "husker", "freaker",
+      "skulls", "bulldog", "flat top", "hammerhead", "gonzo"
+   };
+   char **str, **str2;
+   Eina_Inarray *iarr;
+   int i;
+
+   eina_init();
+   iarr = eina_inarray_new(sizeof(char *), 0);
+
+   for (i = 0; i < 20; i++){
+      str = &strings[i];
+      eina_inarray_push(iarr, str);
+   }
+
+   printf("Inline array of strings:\n");
+   EINA_INARRAY_FOREACH(iarr, str2)
+     printf("string: %s(pointer: %p)\n", *str2, str2);
+
+   eina_inarray_free(iarr);
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_inlist_01.c b/src/examples/eina/eina_inlist_01.c
new file mode 100644
index 0000000000..58a3d66854
--- /dev/null
+++ b/src/examples/eina/eina_inlist_01.c
@@ -0,0 +1,98 @@
+// Compile with:
+// gcc -g eina_inlist_01.c -o eina_inlist_01 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+#include <stdio.h>
+
+struct my_struct {
+     EINA_INLIST;
+     int a, b;
+};
+
+int
+sort_cb(const void *d1, const void *d2)
+{
+   const Eina_Inlist *l1, *l2;
+   const struct my_struct *x1, *x2;
+
+   l1 = d1;
+   l2 = d2;
+
+   x1 = EINA_INLIST_CONTAINER_GET(l1, struct my_struct);
+   x2 = EINA_INLIST_CONTAINER_GET(l2, struct my_struct);
+
+   return x1->a - x2->a;
+}
+
+int
+main(void)
+{
+   struct my_struct *d, *cur;
+   Eina_Inlist *list, *itr, *tmp;
+
+   eina_init();
+
+   d = malloc(sizeof(*d));
+   d->a = 1;
+   d->b = 10;
+   list = eina_inlist_append(NULL, EINA_INLIST_GET(d));
+
+   d = malloc(sizeof(*d));
+   d->a = 2;
+   d->b = 20;
+   list = eina_inlist_append(list, EINA_INLIST_GET(d));
+
+   d = malloc(sizeof(*d));
+   d->a = 3;
+   d->b = 30;
+   list = eina_inlist_prepend(list, EINA_INLIST_GET(d));
+
+   printf("list=%p\n", list);
+   EINA_INLIST_FOREACH(list, cur)
+     printf("\ta=%d, b=%d\n", cur->a, cur->b);
+
+   list = eina_inlist_promote(list, EINA_INLIST_GET(d));
+
+   d = malloc(sizeof(*d));
+   d->a = 4;
+   d->b = 40;
+   list = eina_inlist_append_relative(list, EINA_INLIST_GET(d), list);
+
+   list = eina_inlist_demote(list, EINA_INLIST_GET(d));
+
+   list = eina_inlist_sort(list, sort_cb);
+
+   printf("list after sort=%p\n", list);
+   EINA_INLIST_FOREACH(list, cur)
+     printf("\ta=%d, b=%d\n", cur->a, cur->b);
+
+   tmp = eina_inlist_find(list, EINA_INLIST_GET(d));
+   if (tmp)
+     cur = EINA_INLIST_CONTAINER_GET(tmp, struct my_struct);
+   else
+     cur = NULL;
+
+   if (d != cur)
+     printf("wrong node! cur=%p\n", cur);
+
+   list = eina_inlist_remove(list, EINA_INLIST_GET(d));
+   free(d);
+   printf("list=%p\n", list);
+   for (itr = list; itr != NULL; itr = itr->next)
+     {
+        cur = EINA_INLIST_CONTAINER_GET(itr, struct my_struct);
+        printf("\ta=%d, b=%d\n", cur->a, cur->b);
+     }
+
+   while (list)
+     {
+        struct my_struct *aux = EINA_INLIST_CONTAINER_GET(list,
+                                                          struct my_struct);
+        list = eina_inlist_remove(list, list);
+        free(aux);
+     }
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_inlist_02.c b/src/examples/eina/eina_inlist_02.c
new file mode 100644
index 0000000000..79dc0cdbcd
--- /dev/null
+++ b/src/examples/eina/eina_inlist_02.c
@@ -0,0 +1,66 @@
+// Compile with:
+// gcc -g eina_inlist_02.c -o eina_inlist_02 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+#include <stdio.h>
+
+struct my_struct {
+     EINA_INLIST;
+     int a, b;
+};
+
+int
+main(void)
+{
+   struct my_struct *d, *cur;
+   int i;
+
+   Eina_Inlist *inlist = NULL;
+   Eina_List *list = NULL, *l_itr, *l_next;
+
+   eina_init();
+
+   for (i = 0; i < 100; i++)
+     {
+        d = malloc(sizeof(*d));
+        d->a = i;
+        d->b = i * 10;
+        inlist = eina_inlist_append(inlist, EINA_INLIST_GET(d));
+        if ((i % 2) == 0)
+          list = eina_list_prepend(list, d);
+     }
+
+   printf("inlist=%p\n", inlist);
+   EINA_INLIST_FOREACH(inlist, cur)
+     printf("\ta=%d, b=%d\n", cur->a, cur->b);
+
+   printf("list=%p\n", list);
+   EINA_LIST_FOREACH(list, l_itr, cur)
+     printf("\ta=%d, b=%d\n", cur->a, cur->b);
+
+   printf("inlist count=%d\n", eina_inlist_count(inlist));
+   printf("list count=%d\n\n", eina_list_count(list));
+
+   EINA_LIST_FOREACH_SAFE(list, l_itr, l_next, cur)
+     {
+        if ((cur->a % 3) == 0)
+          list = eina_list_remove_list(list, l_itr);
+     }
+
+   printf("inlist count=%d\n", eina_inlist_count(inlist));
+   printf("list count=%d\n\n", eina_list_count(list));
+
+   eina_list_free(list);
+
+   while (inlist)
+     {
+        struct my_struct *aux = EINA_INLIST_CONTAINER_GET(inlist,
+                                                          struct my_struct);
+        inlist = eina_inlist_remove(inlist, inlist);
+        free(aux);
+     }
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_inlist_03.c b/src/examples/eina/eina_inlist_03.c
new file mode 100644
index 0000000000..6a9ff64197
--- /dev/null
+++ b/src/examples/eina/eina_inlist_03.c
@@ -0,0 +1,75 @@
+// Compile with:
+// gcc -g eina_inlist_03.c -o eina_inlist_03 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+#include <stdio.h>
+
+struct my_struct {
+     EINA_INLIST;
+     Eina_Inlist even;
+     int a, b;
+};
+
+#define EVEN_INLIST_GET(Inlist) (& ((Inlist)->even))
+
+#define EVEN_INLIST_CONTAINER_GET(ptr, type) \
+   ((type *)((char *)ptr - offsetof(type, even)))
+
+int
+main(void)
+{
+   struct my_struct *d, *cur;
+   int i;
+
+   Eina_Inlist *list = NULL, *list_even = NULL, *itr;
+
+   eina_init();
+
+   for (i = 0; i < 100; i++)
+     {
+        d = malloc(sizeof(*d));
+        d->a = i;
+        d->b = i * 10;
+        list = eina_inlist_append(list, EINA_INLIST_GET(d));
+        if ((i % 2) == 0)
+          list_even = eina_inlist_prepend(list_even, EVEN_INLIST_GET(d));
+     }
+
+   printf("list=%p\n", list);
+   EINA_INLIST_FOREACH(list, cur)
+     printf("\ta=%d, b=%d\n", cur->a, cur->b);
+
+   printf("list_even=%p\n", list_even);
+   for (itr = list_even; itr != NULL; itr = itr->next)
+     {
+        cur = EVEN_INLIST_CONTAINER_GET(itr, struct my_struct);
+        printf("\ta=%d, b=%d\n", cur->a, cur->b);
+     }
+
+   printf("list count=%d\n", eina_inlist_count(list));
+   printf("list_even count=%d\n\n", eina_inlist_count(list_even));
+
+   itr = list_even;
+   while (itr)
+     {
+        Eina_Inlist *next = itr->next;
+        cur = EVEN_INLIST_CONTAINER_GET(itr, struct my_struct);
+        if ((cur->a % 3) == 0)
+          list_even = eina_inlist_remove(list_even, itr);
+        itr = next;
+     }
+   printf("list count=%d\n", eina_inlist_count(list));
+   printf("list_even count=%d\n\n", eina_inlist_count(list_even));
+
+   while (list)
+     {
+        struct my_struct *aux = EINA_INLIST_CONTAINER_GET(list,
+                                                          struct my_struct);
+        list = eina_inlist_remove(list, list);
+        free(aux);
+     }
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_iterator_01.c b/src/examples/eina/eina_iterator_01.c
new file mode 100644
index 0000000000..88c40cc695
--- /dev/null
+++ b/src/examples/eina/eina_iterator_01.c
@@ -0,0 +1,66 @@
+//Compile with:
+//gcc -g eina_iterator_01.c -o eina_iterator_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+
+#include <Eina.h>
+
+static Eina_Bool
+print_one(const void *container, void *data, void *fdata)
+{
+   printf("%s\n", (char*)data);
+   return EINA_TRUE;
+}
+
+static void
+print_eina_container(Eina_Iterator *it)
+{
+   eina_iterator_foreach(it, print_one, NULL);
+   printf("\n");
+}
+
+int
+main(int argc, char **argv)
+{
+   const char *strings[] = {
+      "unintersting string", "husker", "starbuck", "husker"
+   };
+   const char *more_strings[] = {
+      "very unintersting string",
+      "what do your hear?",
+      "nothing but the rain",
+      "then grab your gun and bring the cat in"
+   };
+   Eina_Array *array;
+   Eina_List *list = NULL;
+   Eina_Iterator *it;
+   unsigned short int i;
+   char *uninteresting;
+
+   eina_init();
+
+   array = eina_array_new(4);
+
+   for (i = 0; i < 4; i++)
+      {
+        eina_array_push(array, strings[i]);
+        list = eina_list_append(list, more_strings[i]);
+      }
+
+   it = eina_array_iterator_new(array);
+   eina_iterator_next(it, &uninteresting);
+   print_eina_container(it);
+   eina_array_free(eina_iterator_container_get(it));
+   eina_iterator_free(it);
+
+   it = eina_list_iterator_new(list);
+   eina_iterator_next(it, &uninteresting);
+   print_eina_container(it);
+   eina_iterator_free(it);
+
+   eina_list_free(list);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_list_01.c b/src/examples/eina/eina_list_01.c
new file mode 100644
index 0000000000..4fcb020781
--- /dev/null
+++ b/src/examples/eina/eina_list_01.c
@@ -0,0 +1,44 @@
+//Compile with:
+//gcc -g eina_list_01.c -o eina_list_01 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   Eina_List *list = NULL;
+   Eina_List *l;
+   void *list_data;
+
+   eina_init();
+
+   list = eina_list_append(list, "tigh");
+   list = eina_list_append(list, "adar");
+   list = eina_list_append(list, "baltar");
+   list = eina_list_append(list, "roslin");
+
+   EINA_LIST_FOREACH(list, l, list_data)
+     printf("%s\n", (char*)list_data);
+   printf("\n");
+
+   l = eina_list_nth_list(list, 1);
+   list = eina_list_append_relative_list(list, "cain", l);
+
+   list = eina_list_append_relative(list, "zarek", "cain");
+
+   list = eina_list_prepend(list, "adama");
+
+   list = eina_list_prepend_relative(list, "gaeta", "cain");
+
+   list = eina_list_prepend_relative_list(list, "lampkin", l);
+
+   EINA_LIST_FOREACH(list, l, list_data)
+     printf("%s\n", (char*)list_data);
+
+   eina_list_free(list);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_list_02.c b/src/examples/eina/eina_list_02.c
new file mode 100644
index 0000000000..5fe31e89a8
--- /dev/null
+++ b/src/examples/eina/eina_list_02.c
@@ -0,0 +1,55 @@
+//Compile with:
+//gcc -g eina_list_02.c -o eina_list_02 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <string.h>
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   Eina_List *list = NULL, *other_list = NULL;
+   Eina_List *l;
+   void *data;
+   int cmp_result;
+   Eina_Compare_Cb cmp_func = (Eina_Compare_Cb)strcmp;
+
+   eina_init();
+
+   list = eina_list_append(list, "starbuck");
+   list = eina_list_append(list, "appolo");
+   list = eina_list_append(list, "boomer");
+
+   data = eina_list_search_unsorted(list, cmp_func, "boomer");
+   l = eina_list_search_unsorted_list(list, cmp_func, "boomer");
+   if (l->data != data)
+     return 1;
+
+   list = eina_list_sort(list, 0, cmp_func);
+
+   data = eina_list_search_sorted(list, cmp_func, "starbuck");
+   l = eina_list_search_sorted_list(list, cmp_func, "starbuck");
+   if (l->data != data)
+     return 1;
+
+   list = eina_list_sorted_insert(list, cmp_func, "helo");
+
+   l = eina_list_search_sorted_near_list(list, cmp_func, "hera", &cmp_result);
+   if (cmp_result > 0)
+     list = eina_list_prepend_relative_list(list, "hera", l);
+   else if (cmp_result < 0)
+     list = eina_list_append_relative_list(list, "hera", l);
+
+   l = eina_list_search_sorted_list(list, cmp_func, "boomer");
+   list = eina_list_split_list(list, l, &other_list);
+
+   other_list = eina_list_sort(other_list, 0, cmp_func);
+
+   list = eina_list_sorted_merge(list, other_list, cmp_func);
+
+   eina_list_free(list);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_list_03.c b/src/examples/eina/eina_list_03.c
new file mode 100644
index 0000000000..db531489db
--- /dev/null
+++ b/src/examples/eina/eina_list_03.c
@@ -0,0 +1,45 @@
+//Compile with:
+//gcc -g eina_list_03.c -o eina_list_03 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   Eina_List *list = NULL, *r_list;
+   Eina_List *l;
+   Eina_Iterator *itr;
+   void *list_data;
+
+   eina_init();
+
+   list = eina_list_append(list, "caprica");
+   list = eina_list_append(list, "sagitarius");
+   list = eina_list_append(list, "aerilon");
+   list = eina_list_append(list, "gemenon");
+
+   list = eina_list_promote_list(list, eina_list_nth_list(list, 2));
+   list = eina_list_demote_list(list, eina_list_nth_list(list, 2));
+
+   list = eina_list_remove(list, "sagitarius");
+
+   l = eina_list_data_find_list(list, "aerilon");
+   eina_list_data_set(l, "aquarius");
+
+   printf("size: %d\n", eina_list_count(list));
+
+   r_list = eina_list_reverse_clone(list);
+
+   itr = eina_list_iterator_new(r_list);
+   EINA_ITERATOR_FOREACH(itr, list_data)
+     printf("%s\n", (char*)list_data);
+   eina_iterator_free(itr);
+
+   eina_list_free(list);
+   eina_list_free(r_list);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_list_04.c b/src/examples/eina/eina_list_04.c
new file mode 100644
index 0000000000..d92a6076f9
--- /dev/null
+++ b/src/examples/eina/eina_list_04.c
@@ -0,0 +1,36 @@
+//Compile with:
+//gcc -g eina_list_04.c -o eina_list_04 `pkg-config --cflags --libs eina`
+
+#include <stdio.h>
+#include <Eina.h>
+
+int
+main(int argc, char **argv)
+{
+   Eina_List *list = NULL;
+   Eina_List *l;
+   void *list_data;
+
+   eina_init();
+
+   list = eina_list_append(list, eina_stringshare_add("calvin"));
+   list = eina_list_append(list, eina_stringshare_add("Leoben"));
+   list = eina_list_append(list, eina_stringshare_add("D'Anna"));
+   list = eina_list_append(list, eina_stringshare_add("Simon"));
+   list = eina_list_append(list, eina_stringshare_add("Doral"));
+   list = eina_list_append(list, eina_stringshare_add("Six"));
+   list = eina_list_append(list, eina_stringshare_add("Sharon"));
+
+   for(l = list; l; l = eina_list_next(l))
+     printf("%s\n", (char*)l->data);
+
+   for(l = eina_list_last(list); l; l = eina_list_prev(l))
+      printf("%s\n", (char*)eina_list_data_get(l));
+
+   EINA_LIST_FREE(list, list_data)
+     eina_stringshare_del(list_data);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_log_01.c b/src/examples/eina/eina_log_01.c
new file mode 100644
index 0000000000..7a20ca90ac
--- /dev/null
+++ b/src/examples/eina/eina_log_01.c
@@ -0,0 +1,27 @@
+//Compile with:
+//gcc -Wall -o eina_log_01 eina_log_01.c `pkg-config --cflags --libs eina`
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Eina.h>
+
+void test_warn(void)
+{
+   EINA_LOG_WARN("Here is a warning message");
+}
+
+int main(void)
+{
+   if (!eina_init())
+     {
+        printf("log during the initialization of Eina_Log module\n");
+        return EXIT_FAILURE;
+     }
+
+   test_warn();
+
+   eina_shutdown();
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/examples/eina/eina_log_02.c b/src/examples/eina/eina_log_02.c
new file mode 100644
index 0000000000..a056729b2d
--- /dev/null
+++ b/src/examples/eina/eina_log_02.c
@@ -0,0 +1,38 @@
+//Compile with:
+//gcc -Wall -o eina_log_02 eina_log_02.c `pkg-config --cflags --libs eina`
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Eina.h>
+
+void test(int i)
+{
+   EINA_LOG_DBG("Entering test");
+
+   if (i < 0)
+     {
+         EINA_LOG_ERR("Argument is negative");
+         return;
+     }
+
+   EINA_LOG_INFO("argument non negative");
+
+   EINA_LOG_DBG("Exiting test");
+}
+
+int main(void)
+{
+   if (!eina_init())
+     {
+         printf("log during the initialization of Eina_Log module\n");
+         return EXIT_FAILURE;
+     }
+
+   test(-1);
+   test(0);
+
+   eina_shutdown();
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/examples/eina/eina_log_03.c b/src/examples/eina/eina_log_03.c
new file mode 100644
index 0000000000..8dbe19e715
--- /dev/null
+++ b/src/examples/eina/eina_log_03.c
@@ -0,0 +1,78 @@
+//Compile with:
+//gcc -Wall -o eina_log_03 eina_log_03.c `pkg-config --cflags --libs eina`
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Eina.h>
+
+#define log(fmt, ...)                                    \
+   eina_log_print(EINA_LOG_LEVEL_ERR, __FILE__, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+
+typedef struct _Data Data;
+
+struct _Data
+{
+   int to_stderr;
+};
+
+void print_cb(const Eina_Log_Domain *domain,
+              Eina_Log_Level level,
+              const char *file,
+              const char *fnc,
+              int line,
+              const char *fmt,
+              void *data,
+              va_list args)
+{
+   Data *d;
+   FILE *output;
+   char *str;
+
+   d = (Data*)data;
+   if (d->to_stderr)
+     {
+        output = stderr;
+        str = "stderr";
+    }
+   else
+     {
+       output = stdout;
+        str = "stdout";
+     }
+
+   fprintf(output, "%s:%s:%s (%d) %s: ",
+           domain->domain_str, file, fnc, line, str);
+   vfprintf(output, fmt, args);
+   putc('\n', output);
+}
+
+void test(Data *data, int i)
+{
+   if (i < 0)
+      data->to_stderr = 0;
+   else
+      data->to_stderr = 1;
+
+   EINA_LOG_INFO("Log message...");
+}
+
+int main(void)
+{
+   Data data;
+
+   if (!eina_init())
+     {
+        printf("log during the initialization of Eina_Log module\n");
+        return EXIT_FAILURE;
+     }
+
+   eina_log_print_cb_set(print_cb, &data);
+
+   test(&data, -1);
+   test(&data, 0);
+
+   eina_shutdown();
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/examples/eina/eina_magic_01.c b/src/examples/eina/eina_magic_01.c
new file mode 100644
index 0000000000..f42e193695
--- /dev/null
+++ b/src/examples/eina/eina_magic_01.c
@@ -0,0 +1,106 @@
+//Compile with:
+//gcc -g eina_magic_01.c -o eina_magic_01 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+
+#define BASETYPE_MAGIC 0x12345
+struct _person {
+   EINA_MAGIC;
+   char *name;
+};
+typedef struct _person person;
+
+#define SUBTYPE_MAGIC 0x3333
+struct _pilot {
+   person base;
+   EINA_MAGIC;
+   char *callsign;
+};
+typedef struct _pilot pilot;
+
+person *
+person_new(const char *name)
+{
+   person *ptr = malloc(sizeof(person));
+   EINA_MAGIC_SET(ptr, BASETYPE_MAGIC);
+   ptr->name = strdup(name);
+}
+
+void
+person_free(person *ptr) {
+   if (!EINA_MAGIC_CHECK(ptr, BASETYPE_MAGIC))
+   {
+      EINA_MAGIC_FAIL(ptr, BASETYPE_MAGIC);
+      return;
+   }
+   EINA_MAGIC_SET(ptr, EINA_MAGIC_NONE);
+   free(ptr->name);
+   free(ptr);
+}
+
+pilot *
+pilot_new(const char *name, const char *callsign)
+{
+   pilot *ptr = malloc(sizeof(pilot));
+   EINA_MAGIC_SET(ptr, SUBTYPE_MAGIC);
+   EINA_MAGIC_SET(&ptr->base, BASETYPE_MAGIC);
+   ptr->base.name = strdup(name);
+   ptr->callsign = strdup(callsign);
+}
+
+void
+pilot_free(pilot *ptr) {
+   if (!EINA_MAGIC_CHECK(ptr, SUBTYPE_MAGIC))
+   {
+      EINA_MAGIC_FAIL(ptr, SUBTYPE_MAGIC);
+      return;
+   }
+   EINA_MAGIC_SET(ptr, EINA_MAGIC_NONE);
+   EINA_MAGIC_SET(&ptr->base, EINA_MAGIC_NONE);
+   free(ptr->base.name);
+   free(ptr->callsign);
+   free(ptr);
+}
+
+void
+print_person(person *ptr)
+{
+   if (!EINA_MAGIC_CHECK(ptr, BASETYPE_MAGIC)){
+      EINA_MAGIC_FAIL(ptr, BASETYPE_MAGIC);
+      return;
+   }
+   printf("name: %s\n", ptr->name);
+}
+
+void
+print_pilot(pilot *ptr)
+{
+   if (!EINA_MAGIC_CHECK(ptr, SUBTYPE_MAGIC)) {
+      EINA_MAGIC_FAIL(ptr, SUBTYPE_MAGIC);
+      return;
+   }
+   print_person(&ptr->base);
+   printf("callsign: %s\n", ptr->callsign);
+}
+
+int
+main(int argc, char **argv)
+{
+   person *base;
+   pilot *sub;
+
+   eina_init();
+   eina_magic_string_set(BASETYPE_MAGIC, "person");
+   eina_magic_string_static_set(SUBTYPE_MAGIC, "pilot");
+
+   base = person_new("Tyrol");
+   sub = pilot_new("thrace", "starbuck");
+
+   print_person(base);
+   print_person((person *)sub);
+
+   print_pilot(base); //BAD
+   print_pilot(sub);
+
+   eina_shutdown();
+}
diff --git a/src/examples/eina/eina_model_01.c b/src/examples/eina/eina_model_01.c
new file mode 100644
index 0000000000..28895aa666
--- /dev/null
+++ b/src/examples/eina/eina_model_01.c
@@ -0,0 +1,235 @@
+/*
+ * Compile with:
+ * gcc -o eina_model_01 eina_model_01.c `pkg-config --cflags --libs eina`
+ */
+
+/*
+ * This example demonstrates the usage of Eina Model by implementing
+ * Bank Account Class, which is inherited from Base Class;
+ * and Credit Card Class, which is inherited from Bank Account Class.
+ *
+ * Base Class(Eina_Model_Type) --> Bank Account Class --> Credit Card Class
+ *
+ * Bank Account Class implements "bank_account_data_set()" and "print()" methods;
+ * Credit Card Class inherits these two and implements "credit_card_data_set()"
+ *
+ *
+ *  Bank Account Class::print() calls for "_bank_account_data_print"
+ *  Credit Card Class ::print() is reloaded with "_credit_card_data_print()"
+ *  which calls for parent function "_bank_account_data_print"
+ *
+ */
+
+
+#include <Eina.h>
+#include <eina_safety_checks.h>
+
+/*
+ * Defining type for new model type
+ * Model will have two methods
+ */
+typedef struct _Bank_Account_Type
+{
+   Eina_Model_Type parent_class;
+   void (*bank_account_data_set)(Eina_Model *, const char *name, const char *number);
+   void (*print)(Eina_Model *);
+} Bank_Account_Type;
+
+/*
+ * Defining type for Bank Account private data
+ */
+typedef struct _Bank_Account_Data
+{
+   char name[30];
+   char number[30];
+} Bank_Account_Data;
+
+/*
+ * Defining type for Credit Card model type, which will be inherited from Bank Account model type
+ * Model will have two parent's methods and additional one
+ */
+typedef struct _Credit_Card_Type
+{
+   Bank_Account_Type parent_class;
+   void (*credit_card_data_set)(Eina_Model *, const char *, const char *, int) ;
+} Credit_Card_Type;
+
+/*
+ * Defining type for Credit Card private data
+ */
+typedef struct _Credit_Card_Data
+{
+   char number[30];
+   char expiry_date[30];
+   int pin;
+} Credit_Card_Data;
+
+static Bank_Account_Type _BANK_ACCOUNT_TYPE;
+static Credit_Card_Type _CREDIT_CARD_TYPE;
+static Eina_Model_Type *BANK_ACCOUNT_TYPE = (Eina_Model_Type *) &_BANK_ACCOUNT_TYPE;
+static Eina_Model_Type *CREDIT_CARD_TYPE = (Eina_Model_Type *) &_CREDIT_CARD_TYPE;
+
+
+/*
+ * Defining method for for Bank Account data
+ */
+static void
+_bank_account_data_set(Eina_Model *mdl, const char *name, const char *number)
+{
+   Bank_Account_Data *bdata = eina_model_type_private_data_get(mdl, BANK_ACCOUNT_TYPE);
+
+   if (!bdata)
+      printf("ERROR\n");
+
+   if (name != NULL)
+     {
+        strncpy(bdata->name, name, sizeof(bdata->name));
+        bdata->name[sizeof(bdata->number) - 1] = '\0';
+     }
+
+   if (number != NULL)
+     {
+        strncpy(bdata->number, number, sizeof(bdata->number));
+        bdata->number[sizeof(bdata->number) - 1] = '\0';
+     }
+
+   printf("%s :: %s %p\n", eina_model_type_name_get(eina_model_type_get(mdl)) ,__func__, mdl);
+}
+
+
+static void
+_credit_card_data_set(Eina_Model *mdl, const char *number, const char *expiry_date, int pin)
+{
+   Credit_Card_Data *cdata = eina_model_type_private_data_get(mdl, CREDIT_CARD_TYPE);
+
+   if (!cdata)
+      printf("ERROR\n");
+
+   if (number != NULL)
+     {
+        strncpy(cdata->number, number, sizeof(cdata->number));
+        cdata->number[sizeof(cdata->number) - 1] = '\0';
+     }
+
+   if (expiry_date != NULL)
+     {
+        strncpy(cdata->expiry_date, expiry_date, sizeof(cdata->expiry_date));
+        cdata->expiry_date[sizeof(cdata->expiry_date) - 1] = '\0';
+     }
+
+   cdata->pin = pin;
+   printf("%s :: %s %p\n", eina_model_type_name_get(eina_model_type_get(mdl)) ,__func__, mdl);
+}
+
+static void
+_bank_account_data_print(Eina_Model *mdl)
+{
+   const Bank_Account_Data *bdata = eina_model_type_private_data_get(mdl, BANK_ACCOUNT_TYPE);
+
+   printf("\n%s :: %s %p \n\tName: %s(%p)\n\tAccount: %s(%p)\n", eina_model_type_name_get(eina_model_type_get(mdl)) ,__func__, mdl
+         , bdata->name, bdata->name, bdata->number, bdata->number);
+}
+
+static void
+_credit_card_data_print(Eina_Model *mdl)
+{
+   void (*pf)(Eina_Model *);
+   const Eina_Model_Type *ptype = eina_model_type_parent_get(eina_model_type_get(mdl));
+   //const Eina_Model_Type *ptype = eina_model_type_get(mdl);
+
+   pf = eina_model_type_method_resolve(ptype, mdl, Bank_Account_Type, print);
+   if (pf)
+      pf(mdl);
+   else
+      printf("ERROR: %d", __LINE__);
+   const Credit_Card_Data *cdata = eina_model_type_private_data_get(mdl, CREDIT_CARD_TYPE);
+   printf("%s :: %s %p \n\tNumber: %s(%p)\n\tCC Expiry Date: %s(%p)\n\tCC PIN: %d(%p)\n", eina_model_type_name_get(eina_model_type_get(mdl)) ,__func__, mdl
+         , cdata->number, cdata->number, cdata->expiry_date, cdata->expiry_date, cdata->pin, &cdata->pin);
+}
+
+#define BANK_ACCOUNT(x) ((Bank_Account_Type *) x)
+#define CREDIT_CARD(x) ((Credit_Card_Type *) x)
+
+void
+bank_account_data_set(Eina_Model *mdl, const char *name, char *number)
+{
+
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(mdl, BANK_ACCOUNT_TYPE));
+
+   void (*pf)(Eina_Model *, const char *, const char *);
+   pf = eina_model_method_resolve(mdl, Bank_Account_Type, bank_account_data_set);
+   if (pf)
+      pf(mdl, name, number);
+   else
+      printf("ERROR %d\n", __LINE__);
+}
+
+void
+data_print(Eina_Model *mdl)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(mdl, BANK_ACCOUNT_TYPE));
+
+   void (*pf)(Eina_Model *);
+   pf = eina_model_method_resolve(mdl, Bank_Account_Type, print);
+   if (pf)
+      pf(mdl);
+   else
+      printf("ERROR %d\n", __LINE__);
+}
+
+void
+credit_card_data_set(Eina_Model *mdl, const char *number, const char *expiry_date, int pin)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(mdl, CREDIT_CARD_TYPE));
+
+   void (*pf)(Eina_Model *, const char *, const char *, int);
+   pf = eina_model_method_resolve(mdl, Credit_Card_Type, credit_card_data_set);
+   if (pf)
+      pf(mdl, number, expiry_date, pin);
+   else
+      printf("ERROR %d\n", __LINE__);
+}
+
+int main(void)
+{
+   Eina_Model *b, *cc;
+
+   eina_init();
+
+   memset(&_BANK_ACCOUNT_TYPE, 0, sizeof(_BANK_ACCOUNT_TYPE));
+   memset(&_CREDIT_CARD_TYPE, 0, sizeof(_CREDIT_CARD_TYPE));
+
+   BANK_ACCOUNT_TYPE->version = EINA_MODEL_TYPE_VERSION;
+   BANK_ACCOUNT_TYPE->type_size = sizeof(Bank_Account_Type);
+   BANK_ACCOUNT_TYPE->private_size = sizeof(Bank_Account_Data);
+   BANK_ACCOUNT_TYPE->name = "Bank_Account_Model";
+   BANK_ACCOUNT_TYPE->parent = EINA_MODEL_TYPE_GENERIC;
+   BANK_ACCOUNT(BANK_ACCOUNT_TYPE)->bank_account_data_set = _bank_account_data_set;
+   BANK_ACCOUNT(BANK_ACCOUNT_TYPE)->print = _bank_account_data_print;
+
+   CREDIT_CARD_TYPE->version = EINA_MODEL_TYPE_VERSION;
+   CREDIT_CARD_TYPE->type_size = sizeof(Credit_Card_Type);
+   CREDIT_CARD_TYPE->private_size = sizeof(Credit_Card_Data);
+   CREDIT_CARD_TYPE->name = "Credit_Card_Model";
+   CREDIT_CARD_TYPE->parent = BANK_ACCOUNT_TYPE;
+   CREDIT_CARD(CREDIT_CARD_TYPE)->credit_card_data_set = _credit_card_data_set;
+   BANK_ACCOUNT(CREDIT_CARD_TYPE)->print = _credit_card_data_print;
+
+   b = eina_model_new(BANK_ACCOUNT_TYPE);   //creating object of bank class
+   cc = eina_model_new(CREDIT_CARD_TYPE);   //creating object of credit card class
+
+   bank_account_data_set(b, "Bill Clark", "8569214756");
+   bank_account_data_set(cc, "John Smith", "3154789");
+
+   credit_card_data_set(cc, "5803 6589 4786 3279 9173", "01/01/2015", 1234);
+
+   data_print(b);
+   data_print(cc);
+
+   eina_model_unref(b);
+   eina_model_unref(cc);
+
+   eina_shutdown();
+
+   return 0;
+}
diff --git a/src/examples/eina/eina_model_02.c b/src/examples/eina/eina_model_02.c
new file mode 100644
index 0000000000..a2cb693d67
--- /dev/null
+++ b/src/examples/eina/eina_model_02.c
@@ -0,0 +1,61 @@
+//Compile with:
+//gcc -g eina_model_02.c -o eina_model_02 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+
+static void _cb_on_deleted(void *data, Eina_Model *model, const Eina_Model_Event_Description *desc, void *event_info);
+
+int main(void)
+{
+   Eina_Model *m;
+   char *s;
+   int i;
+
+   eina_init();
+
+   m = eina_model_new(EINA_MODEL_TYPE_GENERIC);
+
+   eina_model_event_callback_add(m, "deleted", _cb_on_deleted, NULL);
+
+   //Adding properties to model
+   for (i = 0; i < 5; i++)
+     {
+        Eina_Value val;
+        char name[2] = {'a'+ i, 0};
+        eina_value_setup(&val, EINA_VALUE_TYPE_INT);
+        eina_value_set(&val, i);
+        eina_model_property_set(m, name, &val);
+        eina_value_flush(&val);
+     }
+
+   //Adding children to model
+   for (i = 0; i < 5; i++)
+     {
+        Eina_Value val;
+        Eina_Model *c = eina_model_new(EINA_MODEL_TYPE_GENERIC);
+        eina_value_setup(&val, EINA_VALUE_TYPE_INT);
+        eina_value_set(&val, i);
+        eina_model_property_set(c, "x", &val);
+
+        eina_model_event_callback_add(c, "deleted", _cb_on_deleted, NULL);
+
+        eina_model_child_append(m, c);
+        //Now that the child has been appended to a model, it's parent will manage it's lifecycle
+        eina_model_unref(c);
+        eina_value_flush(&val);
+     }
+
+   s = eina_model_to_string(m);
+   printf("model as string:\n%s\n", s);
+
+   free(s);
+   eina_model_unref(m);
+   eina_shutdown();
+
+   return 0;
+}
+
+static void _cb_on_deleted(void *data, Eina_Model *model, const Eina_Model_Event_Description *desc, void *event_info)
+{
+   printf("deleted %p\n", model);
+}
diff --git a/src/examples/eina/eina_model_03.c b/src/examples/eina/eina_model_03.c
new file mode 100644
index 0000000000..a5e2562f15
--- /dev/null
+++ b/src/examples/eina/eina_model_03.c
@@ -0,0 +1,236 @@
+//Compile with:
+//gcc -g eina_model_03.c -o eina_model_03 `pkg-config --cflags --libs eina`
+
+#include <Eina.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+static Eina_Model_Type *ADDRESS_BOOK_TYPE;
+static Eina_Model_Type *PERSON_TYPE;
+
+static void address_book_init(void);
+
+int main(void)
+{
+   Eina_Model *address_book;
+   Eina_Value val;
+   int i, count;
+   char *s;
+
+   eina_init();
+
+   address_book_init();
+
+   address_book = eina_model_new(ADDRESS_BOOK_TYPE);
+
+   eina_value_setup(&val, EINA_VALUE_TYPE_STRING);
+   eina_value_set(&val, "addr_book.txt");
+   eina_model_property_set(address_book, "filename", &val);
+   eina_value_flush(&val);
+
+   eina_model_load(address_book);
+   s = eina_model_to_string(address_book);
+   printf("model as string:\n%s\n\n", s);
+   free(s);
+
+   count = eina_model_child_count(address_book);
+   printf("Address Book with %d entries:\n", count);
+   for (i = 0; i < count; i++)
+     {
+        Eina_Model *person = eina_model_child_get(address_book, i);
+        Eina_Value nameval, emailval;
+        const char *name, *email;
+
+        eina_model_property_get(person, "name", &nameval);
+        eina_model_property_get(person, "email", &emailval);
+
+        eina_value_get(&nameval, &name);
+        eina_value_get(&emailval, &email);
+
+        printf("%02d \"%s\" <%s>\n", i, name, email);
+
+        // We don't need property values anymore
+        eina_value_flush(&nameval);
+        eina_value_flush(&emailval);
+
+        // We don't need our reference to person anymore
+        eina_model_unref(person);
+     }
+
+   eina_model_unref(address_book);
+   eina_shutdown();
+
+   return 0;
+}
+
+// Structure Descriptions are just used internally in the type constructors:
+static Eina_Value_Struct_Desc *ADDRESS_BOOK_DESC;
+static Eina_Value_Struct_Desc *PERSON_DESC;
+
+static Eina_Bool
+_person_constructor(Eina_Model *model)
+{
+   // call parent type constructor, like "super" in other languages:
+   if (!eina_model_type_constructor(EINA_MODEL_TYPE_STRUCT, model))
+     return EINA_FALSE;
+
+   // Do specific setup of our internal structure, letting it know about
+   // our description
+   return eina_model_struct_set(model, PERSON_DESC, NULL);
+}
+
+static Eina_Bool
+_address_book_constructor(Eina_Model *model)
+{
+   // call parent type constructor, like "super" in other languages:
+   if (!eina_model_type_constructor(EINA_MODEL_TYPE_STRUCT, model))
+     return EINA_FALSE;
+
+   // Do specific setup of our internal structure, letting it know about
+   // our description
+   return eina_model_struct_set(model, ADDRESS_BOOK_DESC, NULL);
+}
+
+static Eina_Bool
+_address_book_load(Eina_Model *model)
+{
+   const char *filename;
+   Eina_Value val;
+   char buf[256];
+   FILE *f;
+
+   // We retrieve filename from property of same name:
+   eina_model_property_get(model, "filename", &val);
+   eina_value_get(&val, &filename);
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(filename, EINA_FALSE);
+
+   f = fopen(filename, "r");
+
+   // Now that we have used filename, we must free its memory holder:
+   eina_value_flush(&val);
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(f, EINA_FALSE);
+
+   while (fgets(buf, sizeof(buf), f))
+     {
+        Eina_Model *person;
+        char *name, *email;
+
+        if (strlen(buf) <= 1)
+          continue;
+
+        name = strtok(buf, "\t");
+        email = strtok(NULL, "\n");
+
+        if ((!name) || (!email)) continue;
+
+        // Create person
+        person = eina_model_new(PERSON_TYPE);
+
+        // Setup value type as string, as our properties are strings:
+        eina_value_setup(&val, EINA_VALUE_TYPE_STRING);
+
+        // Set string properties:
+        eina_value_set(&val, name);
+        eina_model_property_set(person, "name", &val);
+
+        eina_value_set(&val, email);
+        eina_model_property_set(person, "email", &val);
+
+        // Flush value, free string
+        eina_value_flush(&val);
+
+        // Add person to the end of model children
+        eina_model_child_append(model, person);
+
+        // Model already holds its reference to person, we release ours
+        eina_model_unref(person);
+     }
+
+   fclose(f);
+   return EINA_TRUE;
+}
+
+static void
+address_book_init(void)
+{
+   // Declare type for internal struct, this is just used to easily
+   // create Eina_Value_Struct_Member array for Eina_Value_Struct_Desc.
+   //
+   // We don't need this structure outside address_book_init()
+   // as it is managed automatically by Eina_Value_Struct, used by
+   // Eina_Model_Struct! Handy! :-)
+   typedef struct _Person Person;
+   struct _Person
+   {
+      const char *name;
+      const char *email;
+   };
+   static Eina_Value_Struct_Member person_members[] = {
+     // no eina_value_type as they are not constant initializers, see below.
+     EINA_VALUE_STRUCT_MEMBER(NULL, Person, name),
+     EINA_VALUE_STRUCT_MEMBER(NULL, Person, email)
+   };
+   // Values that cannot be set on static declarations since they are not
+   // constant initializers. It is a nitpick from C that we need to deal with
+   // here and on all our other declarations.
+   person_members[0].type = EINA_VALUE_TYPE_STRING;
+   person_members[1].type = EINA_VALUE_TYPE_STRING;
+
+   static Eina_Value_Struct_Desc person_desc = {
+     EINA_VALUE_STRUCT_DESC_VERSION,
+     NULL, // no special operations
+     person_members,
+     EINA_C_ARRAY_LENGTH(person_members),
+     sizeof(Person)
+   };
+   static Eina_Model_Type person_type = EINA_MODEL_TYPE_INIT_NOPRIVATE
+     ("Person_Type",
+      Eina_Model_Type,
+      NULL, // no type as EINA_MODEL_TYPE_STRUCT is not constant initializer!
+      NULL, // no extra interfaces
+      NULL  // no extra events);
+      );
+   person_type.parent = EINA_MODEL_TYPE_STRUCT;
+   // Set our overloaded methods:
+   person_type.constructor = _person_constructor;
+
+   typedef struct _Address_Book Address_Book;
+   struct _Address_Book
+   {
+      const char *filename;
+   };
+   static Eina_Value_Struct_Member address_book_members[] = {
+     // no eina_value_type as they are not constant initializers, see below.
+     EINA_VALUE_STRUCT_MEMBER(NULL, Address_Book, filename)
+   };
+   address_book_members[0].type = EINA_VALUE_TYPE_STRING;
+   static Eina_Value_Struct_Desc address_book_desc = {
+     EINA_VALUE_STRUCT_DESC_VERSION,
+     NULL, // no special operations
+     address_book_members,
+     EINA_C_ARRAY_LENGTH(address_book_members),
+     sizeof(Address_Book)
+   };
+   static Eina_Model_Type address_book_type = EINA_MODEL_TYPE_INIT_NOPRIVATE
+     ("Address_Book_Type",
+      Eina_Model_Type,
+      NULL, // no type as EINA_MODEL_TYPE_STRUCT is not constant initializer!
+      NULL, // no extra interfaces
+      NULL  // no extra events);
+      );
+   address_book_type.parent = EINA_MODEL_TYPE_STRUCT;
+   // Set our overloaded methods:
+   address_book_type.constructor = _address_book_constructor;
+   address_book_type.load = _address_book_load;
+
+   // Expose the configured pointers to public usage:
+   // NOTE: they are static, so they live after this function returns!
+   PERSON_TYPE = &person_type;
+   PERSON_DESC = &person_desc;
+
+   ADDRESS_BOOK_TYPE = &address_book_type;
+   ADDRESS_BOOK_DESC = &address_book_desc;
+}
diff --git a/src/examples/eina/eina_model_04_animal.c b/src/examples/eina/eina_model_04_animal.c
new file mode 100644
index 0000000000..bc9f06b7a8
--- /dev/null
+++ b/src/examples/eina/eina_model_04_animal.c
@@ -0,0 +1,76 @@
+/*
+ * animal.c
+ */
+
+#include "eina_model_04_animal.h"
+
+static Eina_Bool initialized = EINA_FALSE;
+
+static void
+_animal_eat(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Eat Animal\n");
+}
+
+static void
+_animal_breathe(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Breathe Animal\n");
+}
+
+const char *ANIMAL_MODEL_TYPE_NAME = NULL;
+static Animal_Type _ANIMAL_TYPE;
+
+const Eina_Model_Type * const ANIMAL_TYPE = (Eina_Model_Type *) &_ANIMAL_TYPE;
+
+void
+animal_init(void)
+{
+   Eina_Model_Type *type;
+
+   if (initialized) return;
+   initialized = EINA_TRUE;
+
+   ANIMAL_MODEL_TYPE_NAME = "Animal_Model_Type";
+
+   type = (Eina_Model_Type *)&_ANIMAL_TYPE;
+   type->version = EINA_MODEL_TYPE_VERSION;
+   type->name = ANIMAL_MODEL_TYPE_NAME;
+   type->private_size = 0;
+
+   eina_model_type_subclass_setup(type, EINA_MODEL_TYPE_GENERIC);
+
+   /* define extra methods */
+
+   type->type_size = sizeof(Animal_Type);
+   ANIMAL_TYPE(type)->breathe = _animal_breathe;
+   ANIMAL_TYPE(type)->eat = _animal_eat;
+}
+
+void
+animal_breathe(Eina_Model *m)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(m, ANIMAL_TYPE));
+
+   void (*pf)(Eina_Model *m);
+   pf = eina_model_method_resolve(m, Animal_Type, breathe);
+   EINA_SAFETY_ON_NULL_RETURN(pf);
+   printf("%s()   \t", __func__);
+   pf(m);
+}
+
+void
+animal_eat(Eina_Model *m)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(m, ANIMAL_TYPE));
+
+   void (*pf)(Eina_Model *m);
+   pf = eina_model_method_resolve(m, Animal_Type, eat);
+   EINA_SAFETY_ON_NULL_RETURN(pf);
+   printf("%s()    \t", __func__);
+   pf(m);
+}
diff --git a/src/examples/eina/eina_model_04_animal.h b/src/examples/eina/eina_model_04_animal.h
new file mode 100644
index 0000000000..1af94c3831
--- /dev/null
+++ b/src/examples/eina/eina_model_04_animal.h
@@ -0,0 +1,26 @@
+/*
+ * animal.h
+ */
+
+#ifndef ANIMAL_H_
+#define ANIMAL_H_
+
+#include <Eina.h>
+
+extern const char *ANIMAL_MODEL_TYPE_NAME;
+extern const Eina_Model_Type * const ANIMAL_TYPE;
+
+#define ANIMAL_TYPE(x) ((Animal_Type *) (eina_model_type_subclass_check((x), ANIMAL_TYPE) ? (x) : NULL))
+
+typedef struct _Animal_Type
+{
+   Eina_Model_Type parent_class;
+   void (*eat)(Eina_Model *m);
+   void (*breathe)(Eina_Model *m);
+} Animal_Type;
+
+void animal_init(void);
+void animal_breathe(Eina_Model *m);
+void animal_eat(Eina_Model *m);
+
+#endif /* ANIMAL_H_ */
diff --git a/src/examples/eina/eina_model_04_child.c b/src/examples/eina/eina_model_04_child.c
new file mode 100644
index 0000000000..59b8aa5f1a
--- /dev/null
+++ b/src/examples/eina/eina_model_04_child.c
@@ -0,0 +1,81 @@
+/*
+ * child.c
+ */
+
+#include "eina_model_04_child.h"
+#include "eina_model_04_whistler.h"
+
+static Eina_Bool initialized = EINA_FALSE;
+
+static void
+_child_cry(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Cry Child\n");
+}
+
+static void
+_child_dive(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Dive Child\n");
+}
+
+const char *CHILD_MODEL_TYPE_NAME = NULL;
+
+static Child_Type _CHILD_TYPE;
+const Eina_Model_Type * const CHILD_TYPE = (Eina_Model_Type *) &_CHILD_TYPE;
+
+static const Diver_Interface _DIVER_INTERFACE;
+static const Eina_Model_Interface * const DIVER_INTERFACE =
+   (Eina_Model_Interface *) &_DIVER_INTERFACE;
+
+static const Eina_Model_Interface * CLASS_INTERFACE_ARRAY[] =
+   { &_DIVER_INTERFACE.base_interface, NULL }; //this array is for model
+
+void
+child_init()
+{
+   Eina_Model_Type *type;
+
+   if (initialized) return;
+   initialized = EINA_TRUE;
+
+   human_init();
+
+   //overriding Diver Interface
+   Eina_Model_Interface * iface = (Eina_Model_Interface *) &_DIVER_INTERFACE;
+   iface->version = EINA_MODEL_INTERFACE_VERSION;
+   iface->interface_size = sizeof(Diver_Interface);
+   iface->name = DIVER_INTERFACE_NAME;
+   DIVER_INTERFACE(iface)->dive = _child_dive;
+
+   //creating instance of Child type
+   CHILD_MODEL_TYPE_NAME = "Child_Model_Type";
+
+   type = (Eina_Model_Type *) &_CHILD_TYPE;
+   type->version = EINA_MODEL_TYPE_VERSION;
+   type->name = CHILD_MODEL_TYPE_NAME;
+
+   eina_model_type_subclass_setup(type, HUMAN_TYPE);
+
+   type->type_size = sizeof(Child_Type);
+   type->interfaces = CLASS_INTERFACE_ARRAY;
+
+   CHILD_TYPE(type)->cry = _child_cry;
+}
+
+//call for implemented Child Class function
+void
+child_cry(Eina_Model *m)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(m, CHILD_TYPE));
+
+   void (*pf)(Eina_Model *m);
+   pf = eina_model_method_resolve(m, Child_Type, cry);
+   EINA_SAFETY_ON_NULL_RETURN(pf);
+   printf("%s() \t\t", __func__);
+   pf(m);
+}
diff --git a/src/examples/eina/eina_model_04_child.h b/src/examples/eina/eina_model_04_child.h
new file mode 100644
index 0000000000..5424217839
--- /dev/null
+++ b/src/examples/eina/eina_model_04_child.h
@@ -0,0 +1,23 @@
+/*
+ * child.h
+ */
+
+#ifndef CHILD_H_
+#define CHILD_H_
+
+#include "eina_model_04_human.h"
+
+extern const char *CHILD_MODEL_TYPE_NAME;
+extern const Eina_Model_Type * const CHILD_TYPE;
+#define CHILD_TYPE(x) ((Child_Type *) (eina_model_type_subclass_check((x), CHILD_TYPE) ? (x) : NULL))
+
+typedef struct _Child_Type
+{
+   Human_Type parent_class;
+   void (*cry)(Eina_Model *m);
+} Child_Type;
+
+void child_init();
+void child_cry(Eina_Model *m);
+
+#endif /* CHILD_H_ */
diff --git a/src/examples/eina/eina_model_04_human.c b/src/examples/eina/eina_model_04_human.c
new file mode 100644
index 0000000000..d9a10ab2a6
--- /dev/null
+++ b/src/examples/eina/eina_model_04_human.c
@@ -0,0 +1,157 @@
+/*
+ * human.c
+ *
+ */
+
+#include "eina_model_04_human.h"
+#include "eina_model_04_whistler.h"
+
+static Eina_Bool initialized = EINA_FALSE;
+
+static void
+_human_eat(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Salad\n");
+}
+
+static void
+_human_walk(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Walk\n");
+}
+
+static void
+_human_whistle(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Whistle Human\n");
+}
+
+static void
+_human_swim(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Swim Human\n");
+}
+
+static void
+_human_dive(Eina_Model *m)
+{
+   printf("%s\t%s", eina_model_type_name_get(eina_model_type_get(m)),
+         __func__);
+   printf("\t\t Dive Human\n");
+}
+/*
+ * defining Human Model Instance
+ * defining Whistler Interface instance
+ * defining Swimmer Interface instance
+ * defining Diver Interface instance
+ */
+
+const char *HUMAN_MODEL_TYPE_NAME = NULL;
+
+static Human_Type _HUMAN_TYPE;
+const Eina_Model_Type * const HUMAN_TYPE = (Eina_Model_Type *) &_HUMAN_TYPE;
+
+static const Whistler_Interface _WHISTLER_INTERFACE;
+static const Eina_Model_Interface * const WHISTLER_INTERFACE =
+   (Eina_Model_Interface *) &_WHISTLER_INTERFACE;
+
+static const Swimmer_Interface _SWIMMER_INTERFACE;
+static const Eina_Model_Interface * const SWIMMER_INTERFACE =
+   (Eina_Model_Interface *) &_SWIMMER_INTERFACE;
+
+static const Diver_Interface _DIVER_INTERFACE;
+static const Eina_Model_Interface * const DIVER_INTERFACE =
+   (Eina_Model_Interface *) &_DIVER_INTERFACE;
+
+/*
+ * defining parent interfaces for Diver Interface instance
+ * defining Interfaces for Human Model instance
+ */
+static const Eina_Model_Interface * PARENT_INTERFACES_ARRAY[] =
+   { &_SWIMMER_INTERFACE.base_interface, NULL }; //this array is for model
+static const Eina_Model_Interface * MODEL_INTERFACES_ARRAY[] =
+   { &_WHISTLER_INTERFACE.base_interface, &_DIVER_INTERFACE.base_interface,
+      NULL }; //this array is for model
+
+void
+human_init()
+{
+   Eina_Model_Type *type;
+
+   if (initialized) return;
+   initialized = EINA_TRUE;
+
+   animal_init();
+
+   /*
+    * Initializing Whistler Interface Instance
+    */
+   Eina_Model_Interface *iface = (Eina_Model_Interface *) &_WHISTLER_INTERFACE;
+   iface->version = EINA_MODEL_INTERFACE_VERSION;
+   iface->interface_size = sizeof(Whistler_Interface);
+   iface->name = WHISTLER_INTERFACE_NAME;
+   WHISTLER_INTERFACE(iface)->whistle = _human_whistle;
+
+   /*
+    * Initializing Swimmer Interface Instance
+    */
+   iface = (Eina_Model_Interface *) &_SWIMMER_INTERFACE;
+   iface->version = EINA_MODEL_INTERFACE_VERSION;
+   iface->interface_size = sizeof(Swimmer_Interface);
+   iface->name = SWIMMER_INTERFACE_NAME;
+   SWIMMER_INTERFACE(iface)->swim = _human_swim;
+
+   /*
+    * Initializing Diver Interface Instance
+    * Diver_Interface is inherited from Swimmer
+    */
+   iface = (Eina_Model_Interface *) &_DIVER_INTERFACE;
+   iface->version = EINA_MODEL_INTERFACE_VERSION;
+   iface->interface_size = sizeof(Diver_Interface);
+   iface->name = DIVER_INTERFACE_NAME;
+   iface->interfaces = PARENT_INTERFACES_ARRAY;
+   DIVER_INTERFACE(iface)->dive = _human_dive;
+
+   /*
+    * Initializing instance of Human Model
+    */
+
+   HUMAN_MODEL_TYPE_NAME = "Human_Model_Type";
+   
+   type = (Eina_Model_Type *) &_HUMAN_TYPE;
+   type->version = EINA_MODEL_TYPE_VERSION;
+   type->name = HUMAN_MODEL_TYPE_NAME;
+   type->private_size = 0;
+
+   eina_model_type_subclass_setup(type, ANIMAL_TYPE);
+
+   type->type_size = sizeof(Human_Type);
+   type->interfaces = MODEL_INTERFACES_ARRAY;
+
+   ANIMAL_TYPE(type)->eat = _human_eat;
+   HUMAN_TYPE(type)->walk =_human_walk;
+}
+
+
+/*
+ * call for implemented Human Class function
+ */
+void
+human_walk(Eina_Model *m)
+{
+   EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(m, HUMAN_TYPE));
+
+   void (*pf)(Eina_Model *m);
+   pf = eina_model_method_resolve(m, Human_Type, walk);
+   EINA_SAFETY_ON_NULL_RETURN(pf);
+   printf("%s()    \t", __func__);
+   pf(m);
+}
diff --git a/src/examples/eina/eina_model_04_human.h b/src/examples/eina/eina_model_04_human.h
new file mode 100644
index 0000000000..1ad7518010
--- /dev/null
+++ b/src/examples/eina/eina_model_04_human.h
@@ -0,0 +1,24 @@
+/*
+ * human.h
+ */
+
+#ifndef HUMAN_H_
+#define HUMAN_H_
+
+#include "eina_model_04_animal.h"
+
+extern const char *HUMAN_MODEL_TYPE_NAME;
+extern const Eina_Model_Type * const HUMAN_TYPE;
+
+#define HUMAN_TYPE(x) ((Human_Type *) (eina_model_type_subclass_check((x), ANIMAL_TYPE) ? (x) : NULL))
+
+typedef struct _Human_Type
+{
+   Animal_Type parent_class;
+   void (*walk)(Eina_Model *m);
+} Human_Type;
+
+void human_init();
+void human_walk(Eina_Model *m);
+
+#endif /* HUMAN_H_ */
diff --git a/src/examples/eina/eina_model_04_main.c b/src/examples/eina/eina_model_04_main.c
new file mode 100644
index 0000000000..0e419ec317
--- /dev/null
+++ b/src/examples/eina/eina_model_04_main.c
@@ -0,0 +1,110 @@
+/*
+ * main_animal.c
+ * compile with: gcc eina_model_04_*.c -o eina_model_04 `pkg-config --cflags --libs eina`
+ */
+
+/*
+ * This example demonstrates the extended usage of Eina Model.
+ * Class inheritance and interface implementation
+ *
+ *  Animal Class is inherited from BaseClass and implements
+ *  "_breathe_animal()" and "_eat_animal()" methods.
+ *
+ *  Human Class is inherited from Animal class.
+ *  Parrot Class is inherited from Animal class.
+ *
+ *  Child Class is inherited from Human class.
+ *
+ *  Human Class and Parrot Class implement Whistler Interface.
+ *  Human Class implements Diver Interface. Diver Interface inherited from Swimmer Interface
+ *