Update EFL to latest beta.

16 files changed, 1047 insertions, 216 deletions

diff --git a/libraries/eina/src/include/Eina.h b/libraries/eina/src/include/Eina.h
index 721a991..d99b129 100644
--- a/libraries/eina/src/include/Eina.h
+++ b/libraries/eina/src/include/Eina.h
@@ -1,5 +1,5 @@
 /* EINA - EFL data type library
- * Copyright (C) 2008-2011 Enlightenment Developers:
+ * Copyright (C) 2008-2012 Enlightenment Developers:
  *           Albin "Lutin" Tonnerre <albin.tonnerre@gmail.com>
  *           Alexandre "diaxen" Becoulet <diaxen@free.fr>
  *           Andre Dieb <andre.dieb@gmail.com>
@@ -16,6 +16,7 @@
  *           Tilman Sauerbeck <tilman@code-monkey.de>
  *           Vincent "caro" Torri  <vtorri at univ-evry dot fr>
  *           Tom Hacohen <tom@stosb.com>
+ *           Jonas M. Gastal <jgastal@profusion.mobi>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -46,7 +47,7 @@
  * @mainpage Eina
  *
  * @version 1.1
- * @date 2008-2011
+ * @date 2008-2012
  *
  * @section eina_intro_sec Introduction
  *
@@ -72,6 +73,8 @@
  * @li @ref Eina_Stringshare_Group saves memory by sharing read-only string references.
  * @li @ref Eina_Tiler_Group split, merge and navigates into 2D tiled regions.
  * @li @ref Eina_Trash_Group container of unused but allocated data.
+ * @li @ref Eina_Value_Group container for generic value storage and access.
+ * @li @ref Eina_Model_Group container for data with user defined hierarchy/structure.
  *
  * The tools that are available are (see @ref Eina_Tools_Group):
  * @li @ref Eina_Benchmark_Group helper to write benchmarks.
@@ -101,6 +104,31 @@
  * their elements with an @ref Eina_Iterator_Group, or eventually an
  * @ref Eina_Accessor_Group.
  *
+ * The containers in eina are designed with performance in mind, one consequence
+ * of this is that they @b don't check the validity of data structures given to
+ * them(@ref Eina_Magic_Group).
+ *
+ * The choice of which container to use in each situation is very important in
+ * achieving good performance and readable code. The most common container types
+ * to be used are:
+ * @li List
+ * @li Inline list
+ * @li Array
+ * @li Inline array
+ * @li Hash
+ *
+ * All types have virtues and vices. The following considerations are good
+ * starting point in deciding which container to use:
+ * @li Hashes are appropriate for datasets which will be searched often;
+ * @li arrays are good when accessing members by position;
+ * @li lists provide good versatility for adding elements in any position with
+ * minimal overhead;
+ * @li inline arrays use very little memory and don't cause fragmentation and
+ * therefore are a good option in memory constrained systems;
+ * @li inline lists are the appropriate type to use when the flexibility of a
+ * list is required but the overhead of pointer indirection is not acceptable.
+ * @warning These are general considerations, every situation is different,
+ * don't follow these recommendations blindly.
  *
  * @defgroup Eina_Tools_Group Tools
  *
@@ -120,15 +148,22 @@
  * @author Carsten Haitzler <raster@@rasterman.com>
  * @author Cedric Bail <cedric.bail@@free.fr>
  * @author Corey "atmos" Donohoe <atmos@@atmos.org>
+ * @author Vincent "caro" Torri  <vtorri at univ-evry dot fr>
  * @author Fabiano Fidêncio <fidencio@@profusion.mobi>
  * @author Gustavo Chaves <glima@@profusion.mobi>
  * @author Gustavo Sverzut Barbieri <barbieri@@profusion.mobi>
  * @author Jorge Luis "turran" Zapata <jorgeluis.zapata@@gmail.com>
+ * @author Tilman Sauerbeck <tilman@@code-monkey.de>
  * @author Peter "pfritz" Wehrfritz <peter.wehrfritz@@web.de>
  * @author Raphael Kubo da Costa <kubo@@profusion.mobi>
- * @author Tilman Sauerbeck <tilman@@code-monkey.de>
- * @author Vincent "caro" Torri  <vtorri at univ-evry dot fr>
  * @author Tom Hacohen <tom@@stosb.com>
+ * @author Brett Nash <nash@@nash.id.au>
+ * @author Sebastian Dransfeld <sd@@tango.flipp.net>
+ * @author Myungjae Lee <mjae.lee@@samsung.com>
+ * @author Youness Alaoui <kakaroto@@kakaroto.homelinux.net>
+ * @author Boris "billiob" Faure <billiob@@gmail.com>
+ * @author Sung W. Park <sungwoo@@gmail.com>
+ * @author Guillaume Friloux <guillaume.friloux@@asp64.com>
  *
  * Please contact <enlightenment-devel@lists.sourceforge.net> to get in
  * contact with the developers and maintainers.
@@ -189,6 +224,7 @@ extern "C" {
 #include "eina_mmap.h"
 #include "eina_xattr.h"
 #include "eina_value.h"
+#include "eina_model.h"
 
 #ifdef __cplusplus
 }
diff --git a/libraries/eina/src/include/Makefile.am b/libraries/eina/src/include/Makefile.am
index a818d5f..31ef71e 100644
--- a/libraries/eina/src/include/Makefile.am
+++ b/libraries/eina/src/include/Makefile.am
@@ -64,7 +64,8 @@ eina_refcount.h \
 eina_mmap.h \
 eina_xattr.h \
 eina_value.h \
-eina_inline_value.x
+eina_inline_value.x \
+eina_model.h
 
 # Will be back for developper after 1.1.
 # eina_object.h
diff --git a/libraries/eina/src/include/Makefile.in b/libraries/eina/src/include/Makefile.in
index ea922e5..7e819b8 100644
--- a/libraries/eina/src/include/Makefile.in
+++ b/libraries/eina/src/include/Makefile.in
@@ -46,20 +46,24 @@ DIST_COMMON = $(am__dist_installed_headers_DATA_DIST) \
         $(dist_installed_mainheader_DATA) $(srcdir)/Makefile.am \
         $(srcdir)/Makefile.in $(srcdir)/eina_config.h.in
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/efl_attribute.m4 \
-        $(top_srcdir)/m4/efl_benchmark.m4 \
-        $(top_srcdir)/m4/efl_compiler_flag.m4 \
-        $(top_srcdir)/m4/efl_coverage.m4 $(top_srcdir)/m4/efl_cpu.m4 \
-        $(top_srcdir)/m4/efl_doxygen.m4 \
-        $(top_srcdir)/m4/efl_examples.m4 \
-        $(top_srcdir)/m4/efl_fnmatch.m4 \
-        $(top_srcdir)/m4/efl_path_max.m4 $(top_srcdir)/m4/efl_tests.m4 \
-        $(top_srcdir)/m4/efl_threads.m4 \
-        $(top_srcdir)/m4/efl_voltron.m4 $(top_srcdir)/m4/eina_bench.m4 \
-        $(top_srcdir)/m4/eina_check.m4 $(top_srcdir)/m4/libtool.m4 \
-        $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-        $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-        $(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/eina/eina_bench.m4 \
+        $(top_srcdir)/m4/eina/eina_check.m4 \
+        $(top_srcdir)/m4/common/efl_attribute.m4 \
+        $(top_srcdir)/m4/common/efl_benchmark.m4 \
+        $(top_srcdir)/m4/common/efl_compiler_flag.m4 \
+        $(top_srcdir)/m4/common/efl_coverage.m4 \
+        $(top_srcdir)/m4/common/efl_cpu.m4 \
+        $(top_srcdir)/m4/common/efl_doxygen.m4 \
+        $(top_srcdir)/m4/common/efl_examples.m4 \
+        $(top_srcdir)/m4/common/efl_fnmatch.m4 \
+        $(top_srcdir)/m4/common/efl_path_max.m4 \
+        $(top_srcdir)/m4/common/efl_tests.m4 \
+        $(top_srcdir)/m4/common/efl_threads.m4 \
+        $(top_srcdir)/m4/common/efl_voltron.m4 \
+        $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+        $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+        $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+        $(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
         $(ACLOCAL_M4)
 mkinstalldirs = $(install_sh) -d
@@ -93,9 +97,9 @@ am__dist_installed_headers_DATA_DIST = eina_safety_checks.h \
         eina_inline_str.x eina_strbuf.h eina_ustrbuf.h eina_unicode.h \
         eina_quadtree.h eina_simple_xml_parser.h eina_lock.h \
         eina_prefix.h eina_refcount.h eina_mmap.h eina_xattr.h \
-        eina_value.h eina_inline_value.x eina_inline_lock_wince.x \
-        eina_inline_lock_win32.x eina_inline_lock_posix.x \
-        eina_inline_lock_void.x
+        eina_value.h eina_inline_value.x eina_model.h \
+        eina_inline_lock_wince.x eina_inline_lock_win32.x \
+        eina_inline_lock_posix.x eina_inline_lock_void.x
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
@@ -167,13 +171,13 @@ EINA_CONFIGURE_DEFAULT_MEMPOOL = @EINA_CONFIGURE_DEFAULT_MEMPOOL@
 EINA_CONFIGURE_ENABLE_LOG = @EINA_CONFIGURE_ENABLE_LOG@
 EINA_CONFIGURE_HAVE_DEBUG_THREADS = @EINA_CONFIGURE_HAVE_DEBUG_THREADS@
 EINA_CONFIGURE_HAVE_DIRENT_H = @EINA_CONFIGURE_HAVE_DIRENT_H@
+EINA_CONFIGURE_HAVE_EXOTIC = @EINA_CONFIGURE_HAVE_EXOTIC@
 EINA_CONFIGURE_HAVE_INTTYPES_H = @EINA_CONFIGURE_HAVE_INTTYPES_H@
 EINA_CONFIGURE_HAVE_ON_OFF_THREADS = @EINA_CONFIGURE_HAVE_ON_OFF_THREADS@
 EINA_CONFIGURE_HAVE_STDINT_H = @EINA_CONFIGURE_HAVE_STDINT_H@
 EINA_CONFIGURE_HAVE_THREADS = @EINA_CONFIGURE_HAVE_THREADS@
 EINA_CONFIGURE_MAGIC_DEBUG = @EINA_CONFIGURE_MAGIC_DEBUG@
 EINA_CONFIGURE_SAFETY_CHECKS = @EINA_CONFIGURE_SAFETY_CHECKS@
-EINA_CPPFLAGS = @EINA_CPPFLAGS@
 EINA_LIBS = @EINA_LIBS@
 EINA_SIZEOF_WCHAR_T = @EINA_SIZEOF_WCHAR_T@
 EMEMOA_CFLAGS = @EMEMOA_CFLAGS@
@@ -183,6 +187,8 @@ ESCAPE_LIBS = @ESCAPE_LIBS@
 EVIL_CFLAGS = @EVIL_CFLAGS@
 EVIL_LIBS = @EVIL_LIBS@
 EXEEXT = @EXEEXT@
+EXOTIC_CFLAGS = @EXOTIC_CFLAGS@
+EXOTIC_LIBS = @EXOTIC_LIBS@
 FGREP = @FGREP@
 GLIB_CFLAGS = @GLIB_CFLAGS@
 GLIB_LIBS = @GLIB_LIBS@
@@ -218,6 +224,8 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
@@ -311,8 +319,8 @@ EINAHEADERS = eina_safety_checks.h eina_error.h eina_log.h \
         eina_ustrbuf.h eina_unicode.h eina_quadtree.h \
         eina_simple_xml_parser.h eina_lock.h eina_prefix.h \
         eina_refcount.h eina_mmap.h eina_xattr.h eina_value.h \
-        eina_inline_value.x $(am__append_1) $(am__append_2) \
-        $(am__append_3) $(am__append_4)
+        eina_inline_value.x eina_model.h $(am__append_1) \
+        $(am__append_2) $(am__append_3) $(am__append_4)
 installed_mainheaderdir = $(includedir)/eina-@VMAJ@
 dist_installed_mainheader_DATA = Eina.h eina_config.h
 installed_headersdir = $(includedir)/eina-@VMAJ@/eina
diff --git a/libraries/eina/src/include/eina_array.h b/libraries/eina/src/include/eina_array.h
index 53183b4..4ab3b50 100644
--- a/libraries/eina/src/include/eina_array.h
+++ b/libraries/eina/src/include/eina_array.h
@@ -351,7 +351,7 @@ static inline void     *eina_array_data_get(const Eina_Array *array,
 static inline void      eina_array_data_set(const Eina_Array *array,
                                             unsigned int      idx,
                                             const void       *data) EINA_ARG_NONNULL(1);
-static inline unsigned int eina_array_count_get(const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT EINA_DEPRECATED;
+static inline unsigned int eina_array_count_get(const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
 static inline unsigned int eina_array_count(const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
 
 /**
diff --git a/libraries/eina/src/include/eina_config.h b/libraries/eina/src/include/eina_config.h
index 474edaa..b1108b6 100644
--- a/libraries/eina/src/include/eina_config.h
+++ b/libraries/eina/src/include/eina_config.h
@@ -19,6 +19,15 @@
 #ifndef EINA_CONFIG_H_
 #define EINA_CONFIG_H_
 
+#ifdef EINA_HAVE_EXOTIC_H
+# undef EINA_HAVE_EXOTIC_H
+#endif
+
+
+#ifdef EINA_HAVE_EXOTIC
+# include <Exotic.h>
+#endif
+
 #ifdef EINA_MAGIC_DEBUG
 # undef EINA_MAGIC_DEBUG
 #endif
diff --git a/libraries/eina/src/include/eina_config.h.in b/libraries/eina/src/include/eina_config.h.in
index 2459ace..937d208 100644
--- a/libraries/eina/src/include/eina_config.h.in
+++ b/libraries/eina/src/include/eina_config.h.in
@@ -19,6 +19,15 @@
 #ifndef EINA_CONFIG_H_
 #define EINA_CONFIG_H_
 
+#ifdef EINA_HAVE_EXOTIC_H
+# undef EINA_HAVE_EXOTIC_H
+#endif
+@EINA_CONFIGURE_HAVE_EXOTIC@
+
+#ifdef EINA_HAVE_EXOTIC
+# include <Exotic.h>
+#endif
+
 #ifdef EINA_MAGIC_DEBUG
 # undef EINA_MAGIC_DEBUG
 #endif
diff --git a/libraries/eina/src/include/eina_error.h b/libraries/eina/src/include/eina_error.h
index 2b0ae77..dd87edf 100644
--- a/libraries/eina/src/include/eina_error.h
+++ b/libraries/eina/src/include/eina_error.h
@@ -180,7 +180,7 @@ EAPI const char *eina_error_msg_get(Eina_Error error) EINA_PURE;
 
 /**
  * @brief Find the #Eina_Error corresponding to a message string
- * @param msg The error message string to match (NOT #NULL)
+ * @param msg The error message string to match (NOT @c NULL)
  * @return The #Eina_Error matching @p msg, or 0 on failure
  * This function attempts to match @p msg with its corresponding #Eina_Error value.
  * If no such value is found, 0 is returned.
diff --git a/libraries/eina/src/include/eina_file.h b/libraries/eina/src/include/eina_file.h
index 422fb65..1af22af 100644
--- a/libraries/eina/src/include/eina_file.h
+++ b/libraries/eina/src/include/eina_file.h
@@ -22,6 +22,7 @@
 
 #include <limits.h>
 #include <time.h>
+#include <sys/stat.h>
 
 #include "eina_types.h"
 #include "eina_array.h"
@@ -91,6 +92,13 @@
 typedef struct _Eina_File_Direct_Info Eina_File_Direct_Info;
 
 /**
+ * @typedef Eina_Stat
+ * A typedef to #_Eina_Stat.
+ * @since 1.2
+ */
+typedef struct _Eina_Stat Eina_Stat;
+
+/**
  * @typedef Eina_File_Dir_List_Cb
  * Type for a callback to be called when iterating over the files of a
  * directory.
@@ -149,6 +157,31 @@ struct _Eina_File_Direct_Info
 };
 
 /**
+ * @struct _Eina_Stat
+ * A structure to store informations of a path.
+ * @since 1.2
+ */
+struct _Eina_Stat
+{
+   unsigned long int    dev;
+   unsigned long int    ino;
+   unsigned int         mode;
+   unsigned int         nlink;
+   unsigned int         uid;
+   unsigned int         gid;
+   unsigned long int    rdev;
+   unsigned long int    size;
+   unsigned long int    blksize;
+   unsigned long int    blocks;
+   unsigned long int    atime;
+   unsigned long int    atimensec;
+   unsigned long int    mtime;
+   unsigned long int    mtimensec;
+   unsigned long int    ctime;
+   unsigned long int    ctimensec;
+};
+
+/**
  * @def EINA_FILE_DIR_LIST_CB
  * @brief cast to an #Eina_File_Dir_List_Cb.
  *
@@ -247,6 +280,24 @@ EAPI Eina_Iterator *eina_file_ls(const char *dir) EINA_WARN_UNUSED_RESULT EINA_A
 EAPI Eina_Iterator *eina_file_stat_ls(const char *dir) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
 
 /**
+ * @brief Use information provided by Eina_Iterator of eina_file_stat_ls or eina_file_direct_ls
+ * to call stat in the most efficient way on your system.
+ *
+ * @param container The container returned by the Eina_Iterator using eina_iterator_container_get().
+ * @param info The content of the current Eina_File_Direct_Info provided by the Eina_Iterator
+ * @param buf Where to put the result of the stat
+ * @return On success 0 is returned, On error -1 is returned and errno is set appropriately.
+ *
+ * This function calls fstatat or stat depending on what your system supports. This makes it efficient and simple
+ * to use on your side without complex detection already done inside Eina on what the system can do.
+ *
+ * @see eina_file_direct_ls()
+ * @see eina_file_stat_ls()
+ * @since 1.2
+ */
+EAPI int eina_file_statat(void *container, Eina_File_Direct_Info *info, Eina_Stat *buf) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2, 3);
+
+/**
  * @brief Get an iterator to list the content of a directory, with direct
  * information.
  *
diff --git a/libraries/eina/src/include/eina_inarray.h b/libraries/eina/src/include/eina_inarray.h
index d37c76b..079f1e3 100644
--- a/libraries/eina/src/include/eina_inarray.h
+++ b/libraries/eina/src/include/eina_inarray.h
@@ -24,6 +24,131 @@
 #include "eina_accessor.h"
 
 /**
+ * @page eina_inarray_example_01 Eina inline array usage
+ * @dontinclude eina_inarray_01.c
+ *
+ * This example will create an inline array of chars, add some elements, print
+ * it, re-purpose the array to store ints, add some elements and print that.
+ *
+ * We'll start with a function to compare ints we need this because the '>'
+ * operator is not a function and can't be used where Eina_Compare_Cb is needed.
+ * @skip int
+ * @until }
+ *
+ * And then move on to the code we actually care about, starting with variable
+ * declarations and eina initialization:
+ * @until eina_init
+ *
+ * Creating an inline array is very simple, we just need to know what type we
+ * want to store:
+ * @until inarray_new
+ * @note The second parameter(the step) is left at zero which means that eina
+ * will choose an appropriate value, this should @b only be changed if it's
+ * known, beforehand, how many elements the array will have.
+ *
+ * Once we have an array we can start adding elements to it. Because the
+ * insertion function expect a memory address we have to put the value we want
+ * to store in a variable(this should be no problem since in real world usage
+ * that's usually where the value will be anyways):
+ * @until append
+ * @note Because the inline array copies the value given to it we can later
+ * change @c ch, which we do, without affecting the contents of the array.
+ *
+ * So let's add some more elements:
+ * @until append
+ * @until append
+ * @until append
+ *
+ * We will then iterate over our array and print every position of it. The thing
+ * to note here is not so much the values which will be the expected 'a', 'b',
+ * 'c' and 'd', but rather the memory address of these values, they are
+ * sequential:
+ * @until printf
+ * @until printf
+ *
+ * We'll now use our array to store ints, so we need to first erase every member
+ * currently on the array:
+ * @until _flush
+ *
+ * And then to be able to store a different type on the same array we use the
+ * eina_array_setup() function, which is just like the eina_inarray_new()
+ * function except it receives already allocated memory. This time we're going
+ * to ask eina to use a step of size 4 because that's how many elements we'll be
+ * putting on the array:
+ * @until _setup
+ * @note Strictly speaking the reason to call eina_inarray_setup() is not
+ * because we're storing different type, but rather because our types have
+ * different sizes. Eina inline arrays don't actually know anything about types,
+ * they only deal in blocks of memory of a given size.
+ * @note Since eina_array_setup() receives already allocated memory you can(and
+ * it is in fact good practice) use inline arrays not declared as pointers:
+ * @code
+ * Eina_Inarray arr;
+ * eina_inarray_setup(&arr, sizeof(int), 4);
+ * @endcode
+ *
+ * And now to add our integer values to the array:
+ * @until append
+ * @until append
+ * @until append
+ *
+ * Just to change things up a bit we've left out the 99 value, but will still
+ * add it in such a way to keep the array ordered. There are many ways to do
+ * this, we could use eina_inarray_insert_at(), or we could change the value
+ * of the last member using eina_inarray_replace_at() and then append the values
+ * in the right order, but for no particular reason we're going to use
+ * eina_inarray_insert_sorted() instead:
+ * @until insert_sorted
+ *
+ * We then print the size of our array, and the array itself, much like last
+ * time the values are not surprising, and neither should it be that the memory
+ * addresses are contiguous:
+ * @until printf
+ * @until printf
+ *
+ * Once done we free our array and shutdown eina:
+ * @until }
+ *
+ * The source for this example: @ref eina_inarray_01_c
+ */
+
+/**
+ * @page eina_inarray_01_c eina_inarray_01.c
+ * @include eina_inarray_01.c
+ * @example eina_inarray_01.c
+ */
+
+/**
+ * @page eina_inarray_example_02 Eina inline array of strings
+ * @dontinclude eina_inarray_02.c
+ *
+ * This example will create an inline array of strings, add some elements and
+ * then print them. This example is based on @ref eina_array_01_example_page and
+ * @ref eina_inarray_example_01.
+ *
+ * We start with some variable declarations and eina initialization:
+ * @skip int
+ * @until eina_init
+ *
+ * We then create the array much like we did on @ref eina_inarray_example_01:
+ * @until inarray_new
+ *
+ * The point were this example significantly differs from the first eina inline
+ * array example. We'll not be adding the strings themselves to the array since
+ * their size varies, we'll store pointer to the strings instead. We therefore
+ * use @c char** to populate our inline array:
+ * @until }
+ *
+ * The source for this example: @ref eina_inarray_02_c
+ */
+
+/**
+ * @page eina_inarray_02_c eina_inarray_02.c
+ * @include eina_inarray_02.c
+ * @example eina_inarray_02.c
+ */
+
+/**
  * @addtogroup Eina_Data_Types_Group Data Types
  *
  * @since 1.2
@@ -40,6 +165,19 @@
 /**
  * @defgroup Eina_Inline_Array_Group Inline Array
  *
+ * Inline array is a container that stores the data itself not pointers to data,
+ * this means there is no memory fragmentation, also for small data types(such
+ * as char, short, int, etc.) it's more memory efficient.
+ *
+ * Usage of the inline array is very similar to that of other
+ * @ref Eina_Containers_Group, like all arrays adding elements to the beginning
+ * of the array is a lot more costly than appending, so those operations should
+ * be minimized.
+ *
+ * Examples:
+ * @li @ref eina_inarray_example_01
+ * @li @ref eina_inarray_example_02
+ *
  * @{
  */
 
@@ -531,8 +669,8 @@ EAPI Eina_Accessor *eina_inarray_accessor_new(const Eina_Inarray *array) EINA_MA
  * @since 1.2
  */
 #define EINA_INARRAY_FOREACH(array, itr)                                \
-  for ((itr) = array->members;                                          \
-       (itr) < (((typeof(*itr)*)array->members) + array->len);          \
+  for ((itr) = (array)->members;                                        \
+       (itr) < (((typeof(*itr)*)(array)->members) + (array)->len);      \
        (itr)++)
 
 /**
@@ -552,9 +690,9 @@ EAPI Eina_Accessor *eina_inarray_accessor_new(const Eina_Inarray *array) EINA_MA
  * @since 1.2
  */
 #define EINA_INARRAY_REVERSE_FOREACH(array, itr)                        \
-  for ((itr) = ((((typeof(*(itr))*)array->members) + array->len) - 1);  \
-       (((itr) >= (typeof(*(itr))*)array->members)                      \
-        && (array->members != NULL));                                   \
+  for ((itr) = ((((typeof(*(itr))*)(array)->members) + (array)->len) - 1); \
+       (((itr) >= (typeof(*(itr))*)(array)->members)                    \
+        && ((array)->members != NULL));                                 \
        (itr)--)
 
 /**
diff --git a/libraries/eina/src/include/eina_inline_lock_win32.x b/libraries/eina/src/include/eina_inline_lock_win32.x
index e8363d5..1988724 100644
--- a/libraries/eina/src/include/eina_inline_lock_win32.x
+++ b/libraries/eina/src/include/eina_inline_lock_win32.x
@@ -23,6 +23,9 @@
 
 typedef CRITICAL_SECTION       Eina_Lock;
 typedef struct _Eina_Condition Eina_Condition;
+typedef struct _Eina_RWLock    Eina_RWLock;
+typedef DWORD                  Eina_TLS;
+typedef HANDLE                 Eina_Semaphore;
 
 #if _WIN32_WINNT >= 0x0600
 struct _Eina_Condition
@@ -30,6 +33,13 @@ struct _Eina_Condition
    CRITICAL_SECTION  *mutex;
    CONDITION_VARIABLE condition;
 };
+
+struct _Eina_RWLock
+{
+   SRWLOCK  mutex;
+
+  Eina_Bool is_read_mode : 1;
+};
 #else
 struct _Eina_Condition
 {
@@ -40,28 +50,24 @@ struct _Eina_Condition
    HANDLE            waiters_done;
    Eina_Bool         was_broadcast;
 };
-#endif
 
-typedef struct _Eina_Win32_RWLock Eina_RWLock;
-
-struct _Eina_Win32_RWLock
+struct _Eina_RWLock
 {
-   LONG readers_count;
-   LONG writers_count;
-   int readers;
-   int writers;
+   LONG           readers_count;
+   LONG           writers_count;
+   int            readers;
+   int            writers;
 
    Eina_Lock      mutex;
    Eina_Condition cond_read;
    Eina_Condition cond_write;
 };
+#endif
 
-typedef DWORD     Eina_TLS;
-
-typedef HANDLE    Eina_Semaphore;
 
 EAPI extern Eina_Bool _eina_threads_activated;
 
+
 static inline Eina_Bool
 eina_lock_new(Eina_Lock *mutex)
 {
@@ -143,9 +149,9 @@ eina_condition_new(Eina_Condition *cond, Eina_Lock *mutex)
         CloseHandle(cond->semaphore);
         return EINA_FALSE;
      }
+#endif
 
    return EINA_TRUE;
-#endif
 }
 
 static inline void
@@ -153,6 +159,7 @@ eina_condition_free(Eina_Condition *cond)
 {
 #if _WIN32_WINNT >= 0x0600
    /* Nothing to do */
+   (void)cond;
 #else
    CloseHandle(cond->waiters_done);
    DeleteCriticalSection(&cond->waiters_count_lock);
@@ -309,20 +316,29 @@ eina_condition_signal(Eina_Condition *cond)
        if (!ReleaseSemaphore(cond->semaphore, 1, 0))
          return EINA_FALSE;
     }
+#endif
 
    return EINA_TRUE;
-#endif
 }
 
 static inline Eina_Bool
 eina_rwlock_new(Eina_RWLock *mutex)
 {
+#if _WIN32_WINNT >= 0x0600
+   InitializeSRWLock(&mutex->mutex);
+   return EINA_TRUE;
+#else
    if (!eina_lock_new(&(mutex->mutex))) return EINA_FALSE;
    if (!eina_condition_new(&(mutex->cond_read), &(mutex->mutex)))
      goto on_error1;
    if (!eina_condition_new(&(mutex->cond_write), &(mutex->mutex)))
      goto on_error2;
 
+   mutex->readers_count = 0;
+   mutex->writers_count = 0;
+   mutex->readers = 0;
+   mutex->writers = 0;
+
    return EINA_TRUE;
 
  on_error2:
@@ -330,20 +346,29 @@ eina_rwlock_new(Eina_RWLock *mutex)
  on_error1:
    eina_lock_free(&(mutex->mutex));
    return EINA_FALSE;
+#endif
 }
 
 static inline void
 eina_rwlock_free(Eina_RWLock *mutex)
 {
+#if _WIN32_WINNT >= 0x0600
+   (void)mutex;
+#else
    eina_condition_free(&(mutex->cond_read));
    eina_condition_free(&(mutex->cond_write));
    eina_lock_free(&(mutex->mutex));
+#endif
 }
 
 static inline Eina_Lock_Result
 eina_rwlock_take_read(Eina_RWLock *mutex)
 {
-   DWORD res;
+#if _WIN32_WINNT >= 0x0600
+   AcquireSRWLockShared(&mutex->mutex);
+   mutex->is_read_mode = EINA_TRUE;
+#else
+   DWORD res = 0;
 
    if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
      return EINA_LOCK_FAIL;
@@ -364,6 +389,7 @@ eina_rwlock_take_read(Eina_RWLock *mutex)
    if (res == 0)
      mutex->readers++;
    eina_lock_release(&(mutex->mutex));
+#endif
 
    return EINA_LOCK_SUCCEED;
 }
@@ -371,7 +397,11 @@ eina_rwlock_take_read(Eina_RWLock *mutex)
 static inline Eina_Lock_Result
 eina_rwlock_take_write(Eina_RWLock *mutex)
 {
-   DWORD res;
+#if _WIN32_WINNT >= 0x0600
+   AcquireSRWLockExclusive(&mutex->mutex);
+   mutex->is_read_mode = EINA_FALSE;
+#else
+   DWORD res = 0;
 
    if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
      return EINA_LOCK_FAIL;
@@ -389,8 +419,9 @@ eina_rwlock_take_write(Eina_RWLock *mutex)
           }
         mutex->writers_count--;
      }
-   if (res == 0) mutex->writers_count = 1;
+   if (res == 0) mutex->writers = 1;
    eina_lock_release(&(mutex->mutex));
+#endif
 
    return EINA_LOCK_SUCCEED;
 }
@@ -398,6 +429,12 @@ eina_rwlock_take_write(Eina_RWLock *mutex)
 static inline Eina_Lock_Result
 eina_rwlock_release(Eina_RWLock *mutex)
 {
+#if _WIN32_WINNT >= 0x0600
+   if (mutex->is_read_mode)
+     ReleaseSRWLockShared(&mutex->mutex);
+   else
+     ReleaseSRWLockExclusive(&mutex->mutex);
+#else
    if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
      return EINA_LOCK_FAIL;
 
@@ -433,6 +470,7 @@ eina_rwlock_release(Eina_RWLock *mutex)
           }
      }
    eina_lock_release(&(mutex->mutex));
+#endif
 
    return EINA_LOCK_SUCCEED;
 }
diff --git a/libraries/eina/src/include/eina_inline_stringshare.x b/libraries/eina/src/include/eina_inline_stringshare.x
index bfd7677..19827c5 100644
--- a/libraries/eina/src/include/eina_inline_stringshare.x
+++ b/libraries/eina/src/include/eina_inline_stringshare.x
@@ -43,7 +43,7 @@
  *         #EINA_FALSE if the strings were the same after shared.
  */
 static inline Eina_Bool
-eina_stringshare_replace(const char **p_str, const char *news)
+eina_stringshare_replace(Eina_Stringshare **p_str, const char *news)
 {
    if (*p_str == news) return EINA_FALSE;
 
@@ -72,7 +72,7 @@ eina_stringshare_replace(const char **p_str, const char *news)
  *         #EINA_FALSE if the strings were the same after shared.
  */
 static inline Eina_Bool
-eina_stringshare_replace_length(const char **p_str, const char *news, unsigned int slen)
+eina_stringshare_replace_length(Eina_Stringshare **p_str, const char *news, unsigned int slen)
 {
    if (*p_str == news) return EINA_FALSE;
 
diff --git a/libraries/eina/src/include/eina_inline_value.x b/libraries/eina/src/include/eina_inline_value.x
index 59ec315..33c83f5 100644
--- a/libraries/eina/src/include/eina_inline_value.x
+++ b/libraries/eina/src/include/eina_inline_value.x
@@ -19,8 +19,8 @@
 #ifndef EINA_INLINE_VALUE_X_
 #define EINA_INLINE_VALUE_X_
 
+#include <stdlib.h>
 #include <string.h>
-#include <alloca.h>
 
 #include "eina_stringshare.h"
 
@@ -210,7 +210,7 @@ eina_value_compare(const Eina_Value *a, const Eina_Value *b)
           return 1;
         return 0;
      }
-   else if (type == EINA_VALUE_TYPE_ULONG)
+   else if ((type == EINA_VALUE_TYPE_ULONG) || (type == EINA_VALUE_TYPE_TIMESTAMP))
      {
         unsigned long *ta = (unsigned long *) pa, *tb = (unsigned long *) pb;
         if (*ta < *tb)
@@ -362,7 +362,7 @@ eina_value_vset(Eina_Value *value, va_list args)
         *tmem = va_arg(args, unsigned int);
         return EINA_TRUE;
      }
-   else if (type == EINA_VALUE_TYPE_ULONG)
+   else if ((type == EINA_VALUE_TYPE_ULONG) || (type == EINA_VALUE_TYPE_TIMESTAMP))
      {
         unsigned long *tmem = (unsigned long *) mem;
         *tmem = va_arg(args, unsigned long);
@@ -424,17 +424,22 @@ eina_value_vset(Eina_Value *value, va_list args)
    else if (type == EINA_VALUE_TYPE_STRING)
      {
         const char *str = (const char *) va_arg(args, const char *);
-        free(value->value.ptr);
+        if (value->value.ptr == str) return EINA_TRUE;
         if (!str)
-          value->value.ptr = NULL;
+          {
+             free(value->value.ptr);
+             value->value.ptr = NULL;
+          }
         else
           {
-             value->value.ptr = strdup(str);
-             if (!value->value.ptr)
+             char *tmp = strdup(str);
+             if (!tmp)
                {
                   eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
                   return EINA_FALSE;
                }
+             free(value->value.ptr);
+             value->value.ptr = tmp;
           }
         return EINA_TRUE;
      }
@@ -494,18 +499,22 @@ eina_value_pset(Eina_Value *value, const void *ptr)
           {
              const char * const * pstr = (const char * const *) ptr;
              const char *str = *pstr;
-
-             free(value->value.ptr);
+             if (value->value.ptr == str) return EINA_TRUE;
              if (!str)
-               value->value.ptr = NULL;
+               {
+                  free(value->value.ptr);
+                  value->value.ptr = NULL;
+               }
              else
                {
-                  value->value.ptr = strdup(str);
-                  if (!value->value.ptr)
+                  char *tmp = strdup(str);
+                  if (!tmp)
                     {
                        eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
                        return EINA_FALSE;
                     }
+                  free(value->value.ptr);
+                  value->value.ptr = tmp;
                }
              return EINA_TRUE;
           }
@@ -607,16 +616,7 @@ eina_value_array_vset(Eina_Value *value, unsigned int position, va_list args)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(desc.subtype, mem);
-
-   if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
-   if (!eina_value_type_vset(desc.subtype, mem, args)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc.subtype, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_vset(desc.subtype, mem, args);
 }
 
 static inline Eina_Bool
@@ -749,16 +749,7 @@ eina_value_array_pset(Eina_Value *value, unsigned int position, const void *ptr)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(desc.subtype, mem);
-
-   if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
-   if (!eina_value_type_pset(desc.subtype, mem, ptr)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc.subtype, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_pset(desc.subtype, mem, ptr);
 }
 
 static inline Eina_Bool
@@ -832,6 +823,29 @@ eina_value_array_pappend(Eina_Value *value, const void *ptr)
    return EINA_FALSE;
 }
 
+static inline Eina_Bool
+eina_value_array_value_get(const Eina_Value *src, unsigned int position, Eina_Value *dst)
+{
+   Eina_Value_Array desc;
+
+   EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(src, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
+
+   if (!eina_value_pget(src, &desc))
+     return EINA_FALSE;
+   if (position >= eina_inarray_count(desc.array))
+     return EINA_FALSE;
+   if (!eina_value_setup(dst, desc.subtype))
+     return EINA_FALSE;
+   if (!eina_value_pset(dst, eina_inarray_nth(desc.array, position)))
+     {
+        eina_value_flush(dst);
+        return EINA_FALSE;
+     }
+
+   return EINA_TRUE;
+}
+
 #undef EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL
 
 #define EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, retval)   \
@@ -929,16 +943,7 @@ eina_value_list_vset(Eina_Value *value, unsigned int position, va_list args)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(desc->subtype, mem);
-
-   if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
-   if (!eina_value_type_vset(desc->subtype, mem, args)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc->subtype, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_vset(desc->subtype, mem, args);
 }
 
 static inline Eina_Bool
@@ -1105,16 +1110,7 @@ eina_value_list_pset(Eina_Value *value, unsigned int position, const void *ptr)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(desc->subtype, mem);
-
-   if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
-   if (!eina_value_type_pset(desc->subtype, mem, ptr)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc->subtype, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_pset(desc->subtype, mem, ptr);
 }
 
 static inline Eina_Bool
@@ -1284,9 +1280,7 @@ eina_value_hash_vset(Eina_Value *value, const char *key, va_list args)
      return EINA_FALSE;
 
    mem = eina_hash_find(desc->hash, key);
-   if (mem)
-     eina_value_type_flush(desc->subtype, mem);
-   else
+   if (!mem)
      {
         mem = malloc(desc->subtype->value_size);
         if (!mem)
@@ -1299,18 +1293,15 @@ eina_value_hash_vset(Eina_Value *value, const char *key, va_list args)
              free(mem);
              return EINA_FALSE;
           }
+        if (!eina_value_type_setup(desc->subtype, mem))
+          {
+             eina_value_type_flush(desc->subtype, mem);
+             eina_hash_del_by_key(desc->hash, key);
+             free(mem);
+          }
      }
 
-   if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
-   if (!eina_value_type_vset(desc->subtype, mem, args)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc->subtype, mem);
- error_setup:
-   eina_hash_del_by_key(desc->hash, key);
-   free(mem);
-   return EINA_FALSE;
+   return eina_value_type_vset(desc->subtype, mem, args);
 }
 
 static inline Eina_Bool
@@ -1371,9 +1362,7 @@ eina_value_hash_pset(Eina_Value *value, const char *key, const void *ptr)
      return EINA_FALSE;
 
    mem = eina_hash_find(desc->hash, key);
-   if (mem)
-     eina_value_type_flush(desc->subtype, mem);
-   else
+   if (!mem)
      {
         mem = malloc(desc->subtype->value_size);
         if (!mem)
@@ -1386,18 +1375,15 @@ eina_value_hash_pset(Eina_Value *value, const char *key, const void *ptr)
              free(mem);
              return EINA_FALSE;
           }
+        if (!eina_value_type_setup(desc->subtype, mem))
+          {
+             eina_value_type_flush(desc->subtype, mem);
+             eina_hash_del_by_key(desc->hash, key);
+             free(mem);
+          }
      }
 
-   if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
-   if (!eina_value_type_pset(desc->subtype, mem, ptr)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(desc->subtype, mem);
- error_setup:
-   eina_hash_del_by_key(desc->hash, key);
-   free(mem);
-   return EINA_FALSE;
+   return eina_value_type_pset(desc->subtype, mem, ptr);
 }
 
 static inline Eina_Bool
@@ -1474,15 +1460,7 @@ eina_value_struct_vset(Eina_Value *value, const char *name, va_list args)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(member->type, mem);
-   if (!eina_value_type_setup(member->type, mem)) goto error_setup;
-   if (!eina_value_type_vset(member->type, mem, args)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(member->type, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_vset(member->type, mem, args);
 }
 
 static inline Eina_Bool
@@ -1540,8 +1518,9 @@ eina_value_struct_pset(Eina_Value *value, const char *name, const void *ptr)
    Eina_Value_Struct *st;
    void *mem;
 
-   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, 0);
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
    st = (Eina_Value_Struct *)eina_value_memory_get(value);
    if (!st)
      return EINA_FALSE;
@@ -1552,15 +1531,7 @@ eina_value_struct_pset(Eina_Value *value, const char *name, const void *ptr)
    if (!mem)
      return EINA_FALSE;
 
-   eina_value_type_flush(member->type, mem);
-   if (!eina_value_type_setup(member->type, mem)) goto error_setup;
-   if (!eina_value_type_pset(member->type, mem, ptr)) goto error_set;
-   return EINA_TRUE;
-
- error_set:
-   eina_value_type_flush(member->type, mem);
- error_setup:
-   return EINA_FALSE;
+   return eina_value_type_pset(member->type, mem, ptr);
 }
 
 static inline Eina_Bool
@@ -1571,8 +1542,9 @@ eina_value_struct_pget(const Eina_Value *value, const char *name, void *ptr)
    const void *mem;
    Eina_Bool ret;
 
-   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, 0);
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
    st = (const Eina_Value_Struct *)eina_value_memory_get(value);
    if (!st)
      return EINA_FALSE;
@@ -1586,6 +1558,119 @@ eina_value_struct_pget(const Eina_Value *value, const char *name, void *ptr)
    ret = eina_value_type_pget(member->type, mem, ptr);
    return ret;
 }
+
+static inline Eina_Bool
+eina_value_struct_value_get(const Eina_Value *src, const char *name, Eina_Value *dst)
+{
+   const Eina_Value_Struct_Member *member;
+   const Eina_Value_Struct *st;
+   const void *mem;
+
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(src, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
+   st = (const Eina_Value_Struct *)eina_value_memory_get(src);
+   if (!st)
+     return EINA_FALSE;
+   member = eina_value_struct_member_find(st, name);
+   if (!member)
+     return EINA_FALSE;
+   mem = eina_value_struct_member_memory_get(st, member);
+   if (!mem)
+     return EINA_FALSE;
+   if (!eina_value_setup(dst, member->type))
+     return EINA_FALSE;
+   if (!eina_value_pset(dst, mem))
+     {
+        eina_value_flush(dst);
+        return EINA_FALSE;
+     }
+   return EINA_TRUE;
+}
+
+static inline Eina_Bool
+eina_value_struct_value_set(Eina_Value *dst, const char *name, const Eina_Value *src)
+{
+   const Eina_Value_Struct_Member *member;
+   Eina_Value_Struct *st;
+   void *mem;
+   const void *ptr;
+
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(dst, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(src, EINA_FALSE);
+
+   st = (Eina_Value_Struct *)eina_value_memory_get(dst);
+   if (!st)
+     return EINA_FALSE;
+   member = eina_value_struct_member_find(st, name);
+   if (!member)
+     return EINA_FALSE;
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(src->type == member->type, EINA_FALSE);
+
+   mem = eina_value_struct_member_memory_get(st, member);
+   if (!mem)
+     return EINA_FALSE;
+
+   ptr = eina_value_memory_get(src);
+   if (!ptr)
+     return EINA_FALSE;
+
+   return eina_value_type_pset(member->type, mem, ptr);
+}
+
+static inline Eina_Bool
+eina_value_struct_member_value_get(const Eina_Value *src, const Eina_Value_Struct_Member *member, Eina_Value *dst)
+{
+   const Eina_Value_Struct *st;
+   const void *mem;
+
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(src, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(member, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
+   st = (const Eina_Value_Struct *)eina_value_memory_get(src);
+   if (!st)
+     return EINA_FALSE;
+   mem = eina_value_struct_member_memory_get(st, member);
+   if (!mem)
+     return EINA_FALSE;
+   if (!eina_value_setup(dst, member->type))
+     return EINA_FALSE;
+   if (!eina_value_pset(dst, mem))
+     {
+        eina_value_flush(dst);
+        return EINA_FALSE;
+     }
+   return EINA_TRUE;
+}
+
+static inline Eina_Bool
+eina_value_struct_member_value_set(Eina_Value *dst, const Eina_Value_Struct_Member *member, const Eina_Value *src)
+{
+   Eina_Value_Struct *st;
+   void *mem;
+   const void *ptr;
+
+   EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(dst, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(member, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(src, EINA_FALSE);
+
+   st = (Eina_Value_Struct *)eina_value_memory_get(dst);
+   if (!st)
+     return EINA_FALSE;
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(src->type == member->type, EINA_FALSE);
+
+   mem = eina_value_struct_member_memory_get(st, member);
+   if (!mem)
+     return EINA_FALSE;
+
+   ptr = eina_value_memory_get(src);
+   if (!ptr)
+     return EINA_FALSE;
+
+   return eina_value_type_pset(member->type, mem, ptr);
+}
+
 #undef EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL
 
 
diff --git a/libraries/eina/src/include/eina_list.h b/libraries/eina/src/include/eina_list.h
index db65e17..c8ef06d 100644
--- a/libraries/eina/src/include/eina_list.h
+++ b/libraries/eina/src/include/eina_list.h
@@ -881,13 +881,13 @@ EAPI Eina_List            *eina_list_clone(const Eina_List *list) EINA_WARN_UNUS
  * @brief Sort a list according to the ordering func will return.
  *
  * @param list The list handle to sort.
- * @param size The length of the list to sort.
+ * @param limit The maximum number of list elements to sort.
  * @param func A function pointer that can handle comparing the list data
  * nodes.
  * @return the new head of list.
  *
  * This function sorts @p list. @p size if the number of the first
- * element to sort. If @p size is 0 or greater than the number of
+ * element to sort. If @p limit is 0 or greater than the number of
  * elements in @p list, all the elements are sorted. @p func is used to
  * compare two elements of @p list. If @p list or @p func are @c NULL,
  * this function returns @c NULL.
@@ -920,7 +920,7 @@ EAPI Eina_List            *eina_list_clone(const Eina_List *list) EINA_WARN_UNUS
  *
  * @warning @p list must be a pointer to the first element of the list.
  */
-EAPI Eina_List            *eina_list_sort(Eina_List *list, unsigned int size, Eina_Compare_Cb func) EINA_ARG_NONNULL(3) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List            *eina_list_sort(Eina_List *list, unsigned int limit, Eina_Compare_Cb func) EINA_ARG_NONNULL(3) EINA_WARN_UNUSED_RESULT;
 
 
 /**
diff --git a/libraries/eina/src/include/eina_stringshare.h b/libraries/eina/src/include/eina_stringshare.h
index 862b2b2..8edadd2 100644
--- a/libraries/eina/src/include/eina_stringshare.h
+++ b/libraries/eina/src/include/eina_stringshare.h
@@ -126,6 +126,20 @@
  * string creation/destruction speed, reduces memory use and decreases
  * memory fragmentation, so a win all-around.
  *
+ * Using eina stringshares usually boils down to:
+ * @code
+ * const char *str = eina_stringshare_add("My string");
+ * ...
+ * //Use str
+ * ...
+ * eina_stringshare_del(str);
+ * @endcode
+ * @note It's very important to note that string shares are @b @c const,
+ * changing them will result in undefined behavior.
+ * @note eina_stringshare_del() @b doesn't guarantee the string share will be
+ * freed, it releases a reference to it, but if other references to it still
+ * exist the string share will live until those are released.
+ *
  * The following diagram gives an idea of what happens as you create strings
  * with eina_stringshare_add():
  *
@@ -148,6 +162,15 @@
  * @{
  */
 
+/**
+ * @typedef Eina_Stringshare
+ *
+ * Interchangeable with "const char *" but still a good visual hint for the
+ * purpose. Maybe in the far far future we'll even add strict type checking.
+ *
+ * @since 1.2.0
+ */
+typedef const char Eina_Stringshare;
 
 /**
  * @brief Retrieve an instance of a string for use in a program.
@@ -168,7 +191,7 @@
  *
  * @see eina_share_common_add()
  */
-EAPI const char        *eina_stringshare_add_length(const char *str, unsigned int slen) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Stringshare  *eina_stringshare_add_length(const char *str, unsigned int slen) EINA_WARN_UNUSED_RESULT;
 
 /**
  * @brief Retrieve an instance of a string for use in a program.
@@ -188,7 +211,7 @@ EAPI const char        *eina_stringshare_add_length(const char *str, unsigned in
  *
  * @see eina_stringshare_add_length()
  */
-EAPI const char        *eina_stringshare_add(const char *str) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Stringshare  *eina_stringshare_add(const char *str) EINA_WARN_UNUSED_RESULT;
 
 /**
  * @brief Retrieve an instance of a string for use in a program
@@ -209,7 +232,7 @@ EAPI const char        *eina_stringshare_add(const char *str) EINA_WARN_UNUSED_R
  *
  * @see eina_stringshare_nprintf()
  */
-EAPI const char        *eina_stringshare_printf(const char *fmt, ...) EINA_WARN_UNUSED_RESULT EINA_PRINTF(1, 2);
+EAPI Eina_Stringshare  *eina_stringshare_printf(const char *fmt, ...) EINA_WARN_UNUSED_RESULT EINA_PRINTF(1, 2);
 
 /**
  * @brief Retrieve an instance of a string for use in a program
@@ -231,7 +254,7 @@ EAPI const char        *eina_stringshare_printf(const char *fmt, ...) EINA_WARN_
  *
  * @see eina_stringshare_nprintf()
  */
-EAPI const char        *eina_stringshare_vprintf(const char *fmt, va_list args) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Stringshare  *eina_stringshare_vprintf(const char *fmt, va_list args) EINA_WARN_UNUSED_RESULT;
 
 /**
  * @brief Retrieve an instance of a string for use in a program
@@ -251,7 +274,7 @@ EAPI const char        *eina_stringshare_vprintf(const char *fmt, va_list args)
  *
  * @see eina_stringshare_printf()
  */
-EAPI const char        *eina_stringshare_nprintf(unsigned int len, const char *fmt, ...) EINA_WARN_UNUSED_RESULT EINA_PRINTF(2, 3);
+EAPI Eina_Stringshare  *eina_stringshare_nprintf(unsigned int len, const char *fmt, ...) EINA_WARN_UNUSED_RESULT EINA_PRINTF(2, 3);
 
 /**
  * Increment references of the given shared string.
@@ -267,7 +290,7 @@ EAPI const char        *eina_stringshare_nprintf(unsigned int len, const char *f
  *
  * There is no unref since this is the work of eina_share_common_del().
  */
-EAPI const char        *eina_stringshare_ref(const char *str);
+EAPI Eina_Stringshare  *eina_stringshare_ref(Eina_Stringshare *str);
 
 /**
  * @brief Note that the given string has lost an instance.
@@ -282,7 +305,7 @@ EAPI const char        *eina_stringshare_ref(const char *str);
  * Note that if the given pointer is not shared or NULL, bad things
  * will happen, likely a segmentation fault.
  */
-EAPI void               eina_stringshare_del(const char *str);
+EAPI void               eina_stringshare_del(Eina_Stringshare *str);
 
 /**
  * @brief Note that the given string @b must be shared.
@@ -296,7 +319,7 @@ EAPI void               eina_stringshare_del(const char *str);
  * things will happen, likely a segmentation fault. If in doubt, try
  * strlen().
  */
-EAPI int                eina_stringshare_strlen(const char *str) EINA_PURE EINA_WARN_UNUSED_RESULT;
+EAPI int                eina_stringshare_strlen(Eina_Stringshare *str) EINA_PURE EINA_WARN_UNUSED_RESULT;
 
 /**
  * @brief Dump the contents of the share_common.
@@ -306,8 +329,8 @@ EAPI int                eina_stringshare_strlen(const char *str) EINA_PURE EINA_
  */
 EAPI void               eina_stringshare_dump(void);
 
-static inline Eina_Bool eina_stringshare_replace(const char **p_str, const char *news) EINA_ARG_NONNULL(1);
-static inline Eina_Bool eina_stringshare_replace_length(const char **p_str, const char *news, unsigned int slen) EINA_ARG_NONNULL(1);
+static inline Eina_Bool eina_stringshare_replace(Eina_Stringshare **p_str, const char *news) EINA_ARG_NONNULL(1);
+static inline Eina_Bool eina_stringshare_replace_length(Eina_Stringshare **p_str, const char *news, unsigned int slen) EINA_ARG_NONNULL(1);
 
 #include "eina_inline_stringshare.x"
 
diff --git a/libraries/eina/src/include/eina_types.h b/libraries/eina/src/include/eina_types.h
index 1653949..b0a7cf8 100644
--- a/libraries/eina/src/include/eina_types.h
+++ b/libraries/eina/src/include/eina_types.h
@@ -98,13 +98,13 @@
 
 #ifdef __GNUC__
 # if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-#  define EINA_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
+#  define EINA_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__))
 # else
 #  define EINA_WARN_UNUSED_RESULT
 # endif
 
 # if (!defined(EINA_SAFETY_CHECKS)) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3))
-#  define EINA_ARG_NONNULL(idx, ...) __attribute__ ((nonnull(idx, ## __VA_ARGS__)))
+#  define EINA_ARG_NONNULL(idx, ...) __attribute__ ((__nonnull__(idx, ## __VA_ARGS__)))
 # else
 #  define EINA_ARG_NONNULL(idx, ...)
 # endif
@@ -116,19 +116,23 @@
 # endif
 
 # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
-#  define EINA_MALLOC __attribute__ ((malloc))
-#  define EINA_PURE   __attribute__ ((pure))
+#  define EINA_MALLOC __attribute__ ((__malloc__))
+#  define EINA_PURE   __attribute__ ((__pure__))
 # else
 #  define EINA_MALLOC
 #  define EINA_PURE
 # endif
 
 # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
-#  define EINA_PRINTF(fmt, arg) __attribute__((format (printf, fmt, arg)))
-#  define EINA_SCANF(fmt, arg)  __attribute__((format (scanf, fmt, arg)))
-#  define EINA_FORMAT(fmt)      __attribute__((format_arg(fmt)))
-#  define EINA_CONST        __attribute__((const))
-#  define EINA_NOINSTRUMENT __attribute__((no_instrument_function))
+#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 3)
+#   define EINA_PRINTF(fmt, arg) __attribute__((__format__ (__gnu_printf__, fmt, arg)))
+#  else
+#   define EINA_PRINTF(fmt, arg) __attribute__((__format__ (__printf__, fmt, arg)))
+#  endif
+#  define EINA_SCANF(fmt, arg)  __attribute__((__format__ (__scanf__, fmt, arg)))
+#  define EINA_FORMAT(fmt)      __attribute__((__format_arg__(fmt)))
+#  define EINA_CONST        __attribute__((__const__))
+#  define EINA_NOINSTRUMENT __attribute__((__no_instrument_function__))
 #  define EINA_UNLIKELY(exp)    __builtin_expect((exp), 0)
 #  define EINA_LIKELY(exp)      __builtin_expect((exp), 1)
 # else
@@ -276,6 +280,16 @@ typedef void (*Eina_Free_Cb)(void *data);
 #define EINA_FREE_CB(Function) ((Eina_Free_Cb)Function)
 
 /**
+ * @def EINA_C_ARRAY_LENGTH
+ * Macro to return the array length of a standard c array.
+ * For example:
+ * int foo[] = { 0, 1, 2, 3 };
+ * would return 4 and not 4 * sizeof(int).
+ * @since 1.2.0
+ */
+#define EINA_C_ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+/**
  * @}
  */
 
diff --git a/libraries/eina/src/include/eina_value.h b/libraries/eina/src/include/eina_value.h
index 846c4ef..341781f 100644
--- a/libraries/eina/src/include/eina_value.h
+++ b/libraries/eina/src/include/eina_value.h
@@ -19,12 +19,244 @@
 #ifndef EINA_VALUE_H_
 #define EINA_VALUE_H_
 
+#include <stdarg.h>
+
 #include "eina_types.h"
 #include "eina_fp.h" /* defines int64_t and uint64_t */
 #include "eina_inarray.h"
 #include "eina_list.h"
 #include "eina_hash.h"
-#include <stdarg.h>
+
+/**
+ * @page eina_value_example_01_page Eina_Value usage
+ * @dontinclude eina_value_01.c
+ *
+ * This very simple example shows how to use some of the basic features of eina
+ * value: setting and getting values, converting between types and printing a
+ * value as a string.
+ *
+ * Our main function starts out with the basic, declaring some variables and
+ * initializing eina:
+ * @until eina_init
+ *
+ * Now we can jump into using eina value. We set a value, get this value and
+ * then print it:
+ * @until printf
+ *
+ * In the above snippet of code we printed an @c int value, we can however print
+ * the value as a string:
+ * @until free
+ *
+ * And once done with a value it's good practice to destroy it:
+ * @until eina_value_flush
+ *
+ * We now reuse @c v to store a string, get its value and print it:
+ * @until printf
+ * @note Since @c s is the value and not returned by @c eina_value_to_string()
+ * we don't need to free it.
+ *
+ * Just because we stored a string doesn't mean we can't use the @c
+ * eina_value_to_string() function, we can and it's important to note that it
+ * will return not the stored string but rather a copy of it(one we have to
+ * free):
+ * @until eina_value_flush
+ *
+ * And now to explore conversions between two type we'll create another value:
+ * @until eina_value_setup
+ *
+ * And make sure @c v and @c otherv have different types:
+ * @until eina_value_setup
+ *
+ * We then set a value to @c v and have it converted, to do this we don't need
+ * to tell to which type we want to convert, we just say were we want to store
+ * the converted value and eina value will figure out what to convert to, and
+ * how:
+ * @until eina_value_convert
+ *
+ * And now let's check the conversion worked:
+ * @until printf
+ *
+ * But converting to strings is not particularly exciting, @c
+ * eina_value_to_string() already did that, so now let's make the conversion the
+ * other way around, from string to @c int:
+ * @until printf
+ *
+ * And once done, destroy the values:
+ * @until }
+ *
+ * Full source code: @ref eina_value_01_c
+ */
+
+/**
+ * @page eina_value_01_c eina_value_01.c
+ * @include eina_value_01.c
+ * @example eina_value_01.c
+ */
+
+/**
+ * @page eina_value_example_02_page Eina_Value struct usage
+ * @dontinclude eina_value_02.c
+ *
+ * This example will examine a hypothetical situation in which we had a
+ * structure(which represented parameters) with two fields, and then need to add
+ * a third field to our structure. If using structs directly we'd need to
+ * rewrite every piece of code that touches the struct, by using eina value, and
+ * thus having the compiler not even know the struct, we can reduce the amount
+ * of changes needed and retain interoperability between the old and new format.
+ *
+ * Our example will start with a function that creates descriptions of both of
+ * our structs for eina value usage. The first step is to create a struct and
+ * describe its members:
+ * @until v1_members[1]
+ * @note We can't pass the types of the members to EINA_VALUE_STRUCT_MEMBER
+ * macro because they are not constant initializers.
+ *
+ * So far it should be pretty easy to understand, we said @c My_Struct_V1 has
+ * two members, one of type @c int and another of type @c char. We now create
+ * the description of the actual struct, again nothing overly complex, we signal
+ * which version of EINA_VALUE_STRUCT we're using, we declare no special
+ * operations, our members and our size:
+ * @until V1_DESC
+ *
+ * We now repeat the process for the second version of our struct, the only
+ * difference is the addition of a third parameter of type @c int :
+ * @until V2_DESC
+ * @until }
+ *
+ * We'll now look at a function that sets the values of our structs. For
+ * simplicity's sake we initialize it we random values, a real world case would
+ * read these values from a file, a database or even from the network. The
+ * fundamental detail here is that this function works for both V1 and V2
+ * structs, this is because setting a parameter that a struct that doesn't have
+ * does nothing without throwing any errors:
+ * @until }
+ * @note While using eina_value_struct_set() with an in-existing parameter
+ * causes no error, it does return #EINA_FALSE, to notify it was not possible
+ * to set the value. This could be used to determine that we're handling a V1
+ * struct and take some action based on that.
+ *
+ * The next thing is to do is see what a function that uses the values of the
+ * struct looks like. We'll again be very simplistic in our usage, we'll just
+ * print the values, but a real world case, might send these values to another
+ * process use them to open a network/database connection or anything else.
+ * Since all versions of the struct have @c param1 and @c param2 we'll
+ * unconditionally use them:
+ * @until printf
+ *
+ * The next step is to conditionally use @c param3, which can fortunately be
+ * done in the same step in which we get it's value:
+ * @until }
+ *
+ * There we've now got functions that can both populate and use values from both
+ * our structs, so now let's actually use them in our main function by creating
+ * a struct of each type, initializing them and them using them:
+ * @until }
+ *
+ * This concludes our example. For the full source code see @ref
+ * eina_value_02_c.
+ */
+
+/**
+ * @page eina_value_02_c eina_value_02.c
+ * @include eina_value_02.c
+ * @example eina_value_02.c
+ */
+
+/**
+ * @page eina_value_example_03_page Eina value custom type example
+ * @dontinclude eina_value_03.c
+ *
+ * For this example we'll be creating our own custom type of eina value. Eina
+ * value can already store struct timeval(man gettimeofday for more information)
+ * but it has no type to store struct timezone, so that's what this example will
+ * do.
+ * @note struct timezone is actually obsolete, so using it in real world
+ * programs is probably not a good idea, but this is an example so, bear with
+ * us.
+ *
+ * To create our own custom eina value type we need to define functions to
+ * do the following operations on it:
+ * @li Setup
+ * @li Flush
+ * @li Copy
+ * @li Compare
+ * @li Set
+ * @li Get
+ * @li Conversion
+ *
+ * Most of this functions are very simple, so let's look at them, starting with
+ * setup which only clear the memory so that we can be certain we won't be using
+ * stale data:
+ * @until }
+ *
+ * Now the flush function, which is even simpler, it does nothing, that's
+ * because there is nothing we need to do, all the necessary steps are taken by
+ * eina value itself:
+ * @until }
+ *
+ * Our next function, copy, is a bit more interesting, but not much, it just
+ * casts our void pointers to struct timezone pointers and does the copy:
+ * @until }
+ * @note By now you might be wondering why our functions receive void pointers
+ * instead of pointers to struct timezone, and this is a good point. The reason
+ * for this is that eina value doesn't know anything about our type so it must
+ * use a generic void pointer, casting that pointer into a proper value is the
+ * job of the implementor of the new type.
+ *
+ * Next we have the comparison function, which compares the @c tz_minuteswest
+ * field of struct timezone, we don't compare @c tz_dsttime because that field
+ * is not used in linux:
+ * @until }
+ *
+ * Next we have setting, this however requires not one but rather two functions,
+ * the reason for this is because to be able to receive arguments of any type
+ * eina value uses @ref https://wikipedia.org/wiki/Variadic_functions "variadic
+ * functions", so we need a function to get the argument from a va_list and
+ * another to actually to the setting.
+ *
+ * Lets first look at the pset function which sets the received value to a
+ * pointer:
+ * @until }
+ *
+ * Next we have the vset function which get the argument from the va_list and
+ * passes it to the pset function:
+ * @until }
+ *
+ * And now the function to get the value, a very simple copying of the value to
+ * the given pointer:
+ * @until }
+ *
+ * And finally our conversion function, this is our longest and most interesting
+ * one. For numeric type we simply assign the value of @c tz_minuteswest to the
+ * new type and call a set function using it:
+ * @until EINA_VALUE_TYPE_DOUBLE
+ * @until return
+ * @note It would be a good idea to add checks for over and underflow for these
+ * types and return #EINA_FALSE in thoses cases, we omit this here for brevity.
+ *
+ * For string types we use @c snprintf() to format our @c tz_minuteswest field
+ * and put it in a string(again @c tz_dsttime is ignored because it's not used):
+ * @until }
+ *
+ * Finally we handle any other types by returning an error in that case:
+ * @until }
+ *
+ * Now that we have all the functions, we can populate an @c Eina_Value_Type to
+ * later use it with @c eina_value_setup():
+ * @until }
+ *
+ * We can now finally use our new TZ_TYPE with eina value, so lets conclude our
+ * example by practicing that by setting its value and printing it:
+ * @until }
+ *
+ * For the full source code see @ref eina_value_03_c.
+ */
+
+/**
+ * @page eina_value_03_c eina_value_03.c
+ * @include eina_value_03.c
+ * @example eina_value_03.c
+ */
 
 /**
  * @addtogroup Eina_Data_Types_Group Data Types
@@ -43,6 +275,24 @@
 /**
  * @defgroup Eina_Value_Group Generic Value Storage
  *
+ * Abstracts generic data storage and access to it in an extensible
+ * and efficient way.
+ *
+ * It comes with pre-defined types for numbers, array, list, hash,
+ * blob and structs. It is able to convert between data types,
+ * including to string.
+ *
+ * It is meant for simple data types, providing uniform access and
+ * release functions, useful to exchange data preserving their
+ * types. For more complex hierarchical data, with properties and
+ * children, reference counting, inheritance and interfaces, see @ref
+ * Eina_Model_Group.
+ *
+ * Examples of usage of the Eina_Value API:
+ * @li @ref eina_value_example_01_page
+ * @li @ref eina_value_example_02_page
+ * @li @ref eina_value_example_03_page
+ *
  * @{
  */
 
@@ -67,6 +317,9 @@ typedef struct _Eina_Value_Type Eina_Value_Type;
  * @typedef Eina_Value_Union
  * Union of all known value types.
  *
+ * This is only used to specify the minimum payload memory for #Eina_Value.
+ *
+ * @internal
  * @since 1.2
  */
 typedef union _Eina_Value_Union Eina_Value_Union;
@@ -75,6 +328,9 @@ typedef union _Eina_Value_Union Eina_Value_Union;
  * @union _Eina_Value_Union
  * All possible value types.
  *
+ * This is only used to specify the minimum payload memory for #Eina_Value.
+ *
+ * @internal
  * @since 1.2
  */
 union _Eina_Value_Union
@@ -117,6 +373,15 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_UINT;
 EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_ULONG;
 
 /**
+ * @var EINA_VALUE_TYPE_TIMESTAMP
+ * manages unsigned long type used for timestamps.
+ * @note this is identical in function to EINA_VALUE_TYPE_ULONG
+ *
+ * @since 1.2
+ */
+EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_TIMESTAMP;
+
+/**
  * @var EINA_VALUE_TYPE_UINT64
  * manages unsigned integer of 64 bits type.
  *
@@ -206,10 +471,11 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_STRING;
  *  @li eina_value_array_pget() and eina_value_array_pset()
  *
  * eina_value_set() takes an #Eina_Value_Array where just @c subtype
- * and @c step are used. If there is an @c array, it will be adopted
- * and its contents must be properly configurable as @c subtype
- * expects. eina_value_pset() takes a pointer to an #Eina_Value_Array.
- * For your convenience, use eina_value_array_setup().
+ * and @c step are used. If there is an @c array, it will be copied
+ * (including each item) and its contents must be properly
+ * configurable as @c subtype expects. eina_value_pset() takes a
+ * pointer to an #Eina_Value_Array.  For your convenience, use
+ * eina_value_array_setup().
  *
  * eina_value_get() and eina_value_pget() takes a pointer to
  * #Eina_Value_Array, it's an exact copy of the current structure in
@@ -228,10 +494,11 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_ARRAY;
  *  @li eina_value_list_pget() and eina_value_list_pset()
  *
  * eina_value_set() takes an #Eina_Value_List where just @c subtype is
- * used. If there is an @c list, it will be adopted and its contents
- * must be properly configurable as @c subtype
- * expects. eina_value_pset() takes a pointer to an #Eina_Value_List.
- * For your convenience, use eina_value_list_setup().
+ * used. If there is an @c list, it will be copied (including each
+ * item) and its contents must be properly configurable as @c
+ * subtype expects. eina_value_pset() takes a pointer to an
+ * #Eina_Value_List.  For your convenience, use
+ * eina_value_list_setup().
  *
  * eina_value_get() and eina_value_pget() takes a pointer to
  * #Eina_Value_List, it's an exact copy of the current structure in
@@ -251,9 +518,9 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_LIST;
  *
  * eina_value_set() takes an #Eina_Value_Hash where just @c subtype
  * and @c buckets_power_size are used. If there is an @c hash, it will
- * be adopted and its contents must be properly configurable as @c
- * subtype expects. eina_value_pset() takes a pointer to an
- * #Eina_Value_Hash.  For your convenience, use
+ * be copied (including each item) and its contents must be
+ * properly configurable as @c subtype expects. eina_value_pset()
+ * takes a pointer to an #Eina_Value_Hash.  For your convenience, use
  * eina_value_hash_setup().
  *
  * eina_value_get() and eina_value_pget() takes a pointer to
@@ -310,9 +577,10 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_BLOB;
  *  @li eina_value_struct_pget() and eina_value_struct_pset()
  *
  * eina_value_set() takes an #Eina_Value_Struct where just @c desc is
- * used. If there is an @c memory, it will be adopted and its contents
- * must be properly configurable as @c desc expects. eina_value_pset()
- * takes a pointer to an #Eina_Value_Struct.  For your convenience, use
+ * used. If there is an @c memory, it will be copied (including each
+ * member) and its contents must be properly configurable as @c desc
+ * expects. eina_value_pset() takes a pointer to an
+ * #Eina_Value_Struct.  For your convenience, use
  * eina_value_struct_setup().
  *
  * eina_value_get() and eina_value_pget() takes a pointer to
@@ -324,6 +592,23 @@ EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_BLOB;
 EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_STRUCT;
 
 /**
+ * @var EINA_VALUE_TYPE_MODEL
+ *
+ * manages Eina_Model type. Use the value get/set to change the model
+ * in use, it will increase the reference while in use by the value.
+ *
+ * eina_value_set() takes a pointer to #Eina_Model, increasing the
+ * reference.
+ *
+ * eina_value_get() takes a pointer to pointer to #Eina_Model, it's an
+ * exact copy of the current model, no copies are done, no references
+ * are increased.
+ *
+ * @since 1.2
+ */
+EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_MODEL;
+
+/**
  * @var EINA_ERROR_VALUE_FAILED
  * Error identifier corresponding to value check failure.
  *
@@ -435,7 +720,7 @@ static inline void eina_value_flush(Eina_Value *value) EINA_ARG_NONNULL(1);
  * @param copy destination value object
  * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
  *
- * The @a copy object is considered internalized and its existing
+ * The @a copy object is considered uninitialized and its existing
  * contents are overwritten (just as if eina_value_flush() was called on
  * it).
  *
@@ -812,8 +1097,9 @@ static inline const Eina_Value_Type *eina_value_type_get(const Eina_Value *value
 
 /**
  * @typedef Eina_Value_Array
- * Value type for #EINA_VALUE_TYPE_ARRAY
+ * Value type for #EINA_VALUE_TYPE_ARRAY.
  *
+ * @see #_Eina_Value_Array explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Array Eina_Value_Array;
@@ -821,6 +1107,7 @@ typedef struct _Eina_Value_Array Eina_Value_Array;
 /**
  * @struct _Eina_Value_Array
  * Used to store the array and its subtype.
+ * @since 1.2
  */
 struct _Eina_Value_Array
 {
@@ -1433,6 +1720,22 @@ static inline Eina_Bool eina_value_array_pappend(Eina_Value *value,
                                                  const void *ptr) EINA_ARG_NONNULL(1);
 
 /**
+ * @brief Retrieves a value from the array as an Eina_Value copy.
+ * @param value source value object
+ * @param position index of the member
+ * @param dst where to return the array member
+ * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
+ *
+ * The argument @a dst is considered uninitialized and it's setup to
+ * the type of the member.
+ *
+ * @since 1.2
+ */
+static inline Eina_Bool eina_value_array_value_get(const Eina_Value *src,
+                                                   unsigned int position,
+                                                   Eina_Value *dst) EINA_ARG_NONNULL(1, 3);
+
+/**
  * @}
  */
 
@@ -1446,8 +1749,9 @@ static inline Eina_Bool eina_value_array_pappend(Eina_Value *value,
 
 /**
  * @typedef Eina_Value_List
- * Value type for #EINA_VALUE_TYPE_LIST
+ * Value type for #EINA_VALUE_TYPE_LIST.
  *
+ * @see #_Eina_Value_List explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_List Eina_Value_List;
@@ -1455,6 +1759,7 @@ typedef struct _Eina_Value_List Eina_Value_List;
 /**
  * @struct _Eina_Value_List
  * Used to store the list and its subtype.
+ * @since 1.2
  */
 struct _Eina_Value_List
 {
@@ -2067,8 +2372,9 @@ static inline Eina_Bool eina_value_list_pappend(Eina_Value *value,
 
 /**
  * @typedef Eina_Value_Hash
- * Value type for #EINA_VALUE_TYPE_HASH
+ * Value type for #EINA_VALUE_TYPE_HASH.
  *
+ * @see #_Eina_Value_Hash explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Hash Eina_Value_Hash;
@@ -2076,6 +2382,7 @@ typedef struct _Eina_Value_Hash Eina_Value_Hash;
 /**
  * @struct _Eina_Value_Hash
  * Used to store the hash and its subtype.
+ * @since 1.2
  */
 struct _Eina_Value_Hash
 {
@@ -2409,19 +2716,25 @@ static inline Eina_Bool eina_value_hash_pget(const Eina_Value *value,
 /**
  * @typedef Eina_Value_Blob_Operations
  * How to manage blob. Any @c NULL callback is ignored.
+ * @see #_Eina_Value_Blob_Operations explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Blob_Operations Eina_Value_Blob_Operations;
 
 /**
+ * @def EINA_VALUE_BLOB_OPERATIONS_VERSION
+ * Current API version, used to validate #_Eina_Value_Blob_Operations.
+ */
+#define EINA_VALUE_BLOB_OPERATIONS_VERSION (1)
+
+/**
  * @struct _Eina_Value_Blob_Operations
  * How to manage blob. Any @c NULL callback is ignored.
  * @since 1.2
  */
 struct _Eina_Value_Blob_Operations
 {
-#define EINA_VALUE_BLOB_OPERATIONS_VERSION (1)
-   unsigned int version; /**< must be EINA_VALUE_BLOB_OPERATIONS_VERSION */
+   unsigned int version; /**< must be #EINA_VALUE_BLOB_OPERATIONS_VERSION */
    void (*free)(const Eina_Value_Blob_Operations *ops, void *memory, size_t size);
    void *(*copy)(const Eina_Value_Blob_Operations *ops, const void *memory, size_t size);
    int (*compare)(const Eina_Value_Blob_Operations *ops, const void *data1, size_t size_data1, const void *data2, size_t size_data2);
@@ -2441,12 +2754,16 @@ EAPI extern const Eina_Value_Blob_Operations *EINA_VALUE_BLOB_OPERATIONS_MALLOC;
 
 /**
  * @typedef Eina_Value_Blob
+ * Value type for #EINA_VALUE_TYPE_BLOB.
+ *
+ * @see #_Eina_Value_Blob explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Blob Eina_Value_Blob;
 
 /**
  * @struct _Eina_Value_Blob
+ * Used to store the blob information and management operations.
  * @since 1.2
  */
 struct _Eina_Value_Blob
@@ -2469,6 +2786,11 @@ struct _Eina_Value_Blob
 /**
  * @typedef Eina_Value_Struct_Operations
  * How to manage struct. Any @c NULL callback is ignored.
+ *
+ * A structure can specify alternative methods to allocate, free and
+ * copy itself. See structure definition for all methods.
+ *
+ * @see #_Eina_Value_Struct_Operations explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Struct_Operations Eina_Value_Struct_Operations;
@@ -2476,6 +2798,12 @@ typedef struct _Eina_Value_Struct_Operations Eina_Value_Struct_Operations;
 /**
  * @typedef Eina_Value_Struct_Member
  * Describes a single member of struct.
+ *
+ * The member holds a name, type and its byte offset within the struct
+ * memory. Most Eina_Value_Struct functions takes the member name as
+ * parameter, as in eina_value_struct_set().
+ *
+ * @see #_Eina_Value_Struct_Member explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Struct_Member Eina_Value_Struct_Member;
@@ -2483,30 +2811,39 @@ typedef struct _Eina_Value_Struct_Member Eina_Value_Struct_Member;
 /**
  * @typedef Eina_Value_Struct_Desc
  * Describes the struct by listing its size, members and operations.
+ * @see #_Eina_Value_Struct_Desc explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Struct_Desc Eina_Value_Struct_Desc;
 
 /**
  * @typedef Eina_Value_Struct
+ * Value type for #EINA_VALUE_TYPE_STRUCT.
+ *
+ * @see #_Eina_Value_Struct explains fields.
  * @since 1.2
  */
 typedef struct _Eina_Value_Struct Eina_Value_Struct;
 
 /**
+ * @def EINA_VALUE_STRUCT_OPERATIONS_VERSION
+ * Current API version, used to validate #_Eina_Value_Struct_Operations.
+ */
+#define EINA_VALUE_STRUCT_OPERATIONS_VERSION (1)
+
+/**
  * @struct _Eina_Value_Struct_Operations
  * How to manage struct. Any @c NULL callback is ignored.
  * @since 1.2
  */
 struct _Eina_Value_Struct_Operations
 {
-#define EINA_VALUE_STRUCT_OPERATIONS_VERSION (1)
-   unsigned int version; /**< must be EINA_VALUE_STRUCT_OPERATIONS_VERSION */
-   void *(*alloc)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc);
-   void (*free)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, void *memory);
-   void *(*copy)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const void *memory);
-   int (*compare)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const void *data1, const void *data2);
-   const Eina_Value_Struct_Member *(*find_member)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const char *name); /**< replace the function to find description for member. For huge structures consider using binary search, stringshared, hash or gperf. The default function does linear search using strcmp(). */
+   unsigned int version; /**< must be #EINA_VALUE_STRUCT_OPERATIONS_VERSION */
+   void *(*alloc)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc); /**< How to allocate struct memory to be managed by the Eina_Value */
+   void (*free)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, void *memory); /**< How to release memory managed by the Eina_Value */
+   void *(*copy)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const void *memory); /**< How to copy struct memory from an existing Eina_Value, if not provided alloc() will be used, then every member is copied using eina_value_type_copy() with member's type. */
+   int (*compare)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const void *data1, const void *data2); /**< How to compare two struct memories */
+   const Eina_Value_Struct_Member *(*find_member)(const Eina_Value_Struct_Operations *ops, const Eina_Value_Struct_Desc *desc, const char *name); /**< How to find description for member. For huge structures consider using binary search, stringshared, hash or gperf. The default function does linear search using strcmp(). */
 };
 
 /**
@@ -2539,23 +2876,48 @@ EAPI extern const Eina_Value_Struct_Operations *EINA_VALUE_STRUCT_OPERATIONS_STR
 
 /**
  * @struct _Eina_Value_Struct_Member
+ * Describes a single member of struct.
+ *
+ * The name is used to lookup the member description. This is done as
+ * specified as _Eina_Value_Struct_Operations::find_member(). For
+ * structures with huge number of members, consider using a better
+ * find_member function to quickly finding it! There are two helper
+ * operations provided to help this:
+ * #EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH and
+ * #EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE, both depend on properly
+ * set #_Eina_Value_Struct_Desc and #_Eina_Value_Struct_Member.
+ *
+ * @see #EINA_VALUE_STRUCT_MEMBER
+ * @see #EINA_VALUE_STRUCT_MEMBER_SENTINEL
+ *
  * @since 1.2
  */
 struct _Eina_Value_Struct_Member
 {
-   const char *name;
-   const Eina_Value_Type *type;
-   unsigned int offset;
+   const char *name; /**< member name, used in lookups such as eina_value_struct_get() */
+   const Eina_Value_Type *type; /**< how to use this member */
+   unsigned int offset; /**< where this member is located within the structure memory */
 };
 
 /**
+ * @def EINA_VALUE_STRUCT_DESC_VERSION
+ * Current API version, used to validate #_Eina_Value_Struct_Desc.
+ */
+#define EINA_VALUE_STRUCT_DESC_VERSION (1)
+
+/**
  * @struct _Eina_Value_Struct_Desc
+ * Describes the struct by listing its size, members and operations.
+ *
+ * This is the root of Eina_Value knowledge about the memory it's
+ * handling as a structure. It adds introspection, saying the byte
+ * size of the structure, its members and how to manage such members.
+ *
  * @since 1.2
  */
 struct _Eina_Value_Struct_Desc
 {
-#define EINA_VALUE_STRUCT_DESC_VERSION (1)
-   unsigned int version; /**< must be EINA_VALUE_STRUCT_DESC_VERSION */
+   unsigned int version; /**< must be #EINA_VALUE_STRUCT_DESC_VERSION */
    const Eina_Value_Struct_Operations *ops; /**< operations, if @c NULL defaults will be used. You may use operations to optimize member lookup using binary search or gperf hash. */
    const Eina_Value_Struct_Member *members; /**< array of member descriptions, if @c member_count is zero, then it must be @c NULL terminated. */
    unsigned int member_count; /**< if > 0, specifies number of members. If zero then @c members must be NULL terminated. */
@@ -2586,12 +2948,13 @@ struct _Eina_Value_Struct_Desc
 
 /**
  * @struct _Eina_Value_Struct
+ * Used to store the memory and its description.
  * @since 1.2
  */
 struct _Eina_Value_Struct
 {
-   const Eina_Value_Struct_Desc *desc;
-   void *memory;
+   const Eina_Value_Struct_Desc *desc; /**< How to manage the structure */
+   void *memory; /**< The managed structure memory */
 };
 
 /**
@@ -2702,7 +3065,7 @@ static inline Eina_Bool eina_value_struct_setup(Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_set(Eina_Value *value,
                                               const char *name,
-                                              ...) EINA_ARG_NONNULL(1);
+                                              ...) EINA_ARG_NONNULL(1, 2);
 
 /**
  * @brief Get the generic value from an struct member.
@@ -2770,7 +3133,7 @@ static inline Eina_Bool eina_value_struct_set(Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_get(const Eina_Value *value,
                                               const char *name,
-                                              ...) EINA_ARG_NONNULL(1);
+                                              ...) EINA_ARG_NONNULL(1, 2);
 
 /**
  * @brief Set the generic value in an struct member.
@@ -2786,7 +3149,7 @@ static inline Eina_Bool eina_value_struct_get(const Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_vset(Eina_Value *value,
                                                const char *name,
-                                               va_list args) EINA_ARG_NONNULL(1);
+                                               va_list args) EINA_ARG_NONNULL(1, 2);
 
 /**
  * @brief Get the generic value from an struct member.
@@ -2808,7 +3171,7 @@ static inline Eina_Bool eina_value_struct_vset(Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_vget(const Eina_Value *value,
                                                const char *name,
-                                               va_list args) EINA_ARG_NONNULL(1);
+                                               va_list args) EINA_ARG_NONNULL(1, 2);
 
 /**
  * @brief Set the generic value in an struct member from pointer.
@@ -2875,7 +3238,7 @@ static inline Eina_Bool eina_value_struct_vget(const Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_pset(Eina_Value *value,
                                                const char *name,
-                                               const void *ptr) EINA_ARG_NONNULL(1, 3);
+                                               const void *ptr) EINA_ARG_NONNULL(1, 2, 3);
 
 /**
  * @brief Get the generic value to pointer from an struct member.
@@ -2944,7 +3307,62 @@ static inline Eina_Bool eina_value_struct_pset(Eina_Value *value,
  */
 static inline Eina_Bool eina_value_struct_pget(const Eina_Value *value,
                                                const char *name,
-                                               void *ptr) EINA_ARG_NONNULL(1, 3);
+                                               void *ptr) EINA_ARG_NONNULL(1, 2, 3);
+
+/**
+ * @brief Get the member as Eina_Value copy
+ * @param src source value object
+ * @param name name to find the member
+ * @param dst where to return the member value.
+ *
+ * The argument @a dst is considered uninitialized and it's setup to
+ * the type of the member.
+ *
+ * @since 1.2
+ */
+static inline Eina_Bool eina_value_struct_value_get(const Eina_Value *src,
+                                                    const char *name,
+                                                    Eina_Value *dst) EINA_ARG_NONNULL(1, 2, 3);
+
+/**
+ * @brief Set the member from Eina_Value source
+ * @param dst destination value object
+ * @param name name to find the member
+ * @param src source value
+ *
+ * @since 1.2
+ */
+static inline Eina_Bool eina_value_struct_value_set(Eina_Value *dst,
+                                                    const char *name,
+                                                    const Eina_Value *src) EINA_ARG_NONNULL(1, 2, 3);
+
+/**
+ * @brief Get the member as Eina_Value copy given its member description.
+ * @param src source value object
+ * @param member the member description to use
+ * @param dst where to return the member value.
+ *
+ * The argument @a dst is considered uninitialized and it's setup to
+ * the type of the member.
+ *
+ * @since 1.2
+ */
+static inline Eina_Bool eina_value_struct_member_value_get(const Eina_Value *src,
+                                                           const Eina_Value_Struct_Member *member,
+                                                           Eina_Value *dst) EINA_ARG_NONNULL(1, 2, 3);
+
+/**
+ * @brief Set the member from Eina_Value source
+ * @param dst destination value object
+ * @param member the member description to use
+ * @param src source value
+ *
+ * @since 1.2
+ */
+static inline Eina_Bool eina_value_struct_member_value_set(Eina_Value *dst,
+                                                           const Eina_Value_Struct_Member *member,
+                                                           const Eina_Value *src) EINA_ARG_NONNULL(1, 2, 3);
+
 
 /**
  * @}
@@ -2958,6 +3376,12 @@ static inline Eina_Bool eina_value_struct_pget(const Eina_Value *value,
  */
 
 /**
+ * @def EINA_VALUE_TYPE_VERSION
+ * Current API version, used to validate type.
+ */
+#define EINA_VALUE_TYPE_VERSION (1)
+
+/**
  * @struct _Eina_Value_Type
  * API to access values.
  *
@@ -2965,11 +3389,6 @@ static inline Eina_Bool eina_value_struct_pget(const Eina_Value *value,
  */
 struct _Eina_Value_Type
 {
-   /**
-    * @def EINA_VALUE_TYPE_VERSION
-    * Current API version, used to validate type.
-    */
-#define EINA_VALUE_TYPE_VERSION (1)
    unsigned int version; /**< must be #EINA_VALUE_TYPE_VERSION */
    unsigned int value_size; /**< byte size of value */
    const char *name; /**< name for debug and introspection */