eina: remove Eina_Promise.

5 files changed, 0 insertions, 1519 deletions

diff --git a/src/Makefile_Eina.am b/src/Makefile_Eina.am
index ce04366887..5ac7b15723 100644
--- a/src/Makefile_Eina.am
+++ b/src/Makefile_Eina.am
@@ -96,7 +96,6 @@ lib/eina/eina_util.h \
 lib/eina/eina_quaternion.h \
 lib/eina/eina_vector.h \
 lib/eina/eina_inline_vector.x \
-lib/eina/eina_promise.h \
 lib/eina/eina_bezier.h \
 lib/eina/eina_safepointer.h \
 lib/eina/eina_inline_safepointer.x \
@@ -175,7 +174,6 @@ lib/eina/eina_private.h \
 lib/eina/eina_share_common.h \
 lib/eina/eina_strbuf_common.h \
 lib/eina/eina_quaternion.c \
-lib/eina/eina_promise.c \
 lib/eina/eina_bezier.c \
 lib/eina/eina_safepointer.c \
 lib/eina/eina_freeq.c
diff --git a/src/lib/eina/Eina.h b/src/lib/eina/Eina.h
index 4f1db07e65..16650e31c5 100644
--- a/src/lib/eina/Eina.h
+++ b/src/lib/eina/Eina.h
@@ -268,7 +268,6 @@ extern "C" {
 #include <eina_evlog.h>
 #include <eina_util.h>
 #include <eina_quaternion.h>
-#include <eina_promise.h>
 #include <eina_bezier.h>
 #include <eina_safepointer.h>
 #include <eina_slice.h>
diff --git a/src/lib/eina/eina_main.c b/src/lib/eina/eina_main.c
index 70bd7586e2..5124092437 100644
--- a/src/lib/eina/eina_main.c
+++ b/src/lib/eina/eina_main.c
@@ -156,7 +156,6 @@ EAPI Eina_Inlist *_eina_tracking = NULL;
    S(rbtree);
    S(file);
    S(safepointer);
-   S(promise);
 /* no model for now
    S(model);
  */
@@ -205,7 +204,6 @@ static const struct eina_desc_setup _eina_desc_setup[] = {
    S(rbtree),
    S(file),
    S(safepointer),
-   S(promise)
 /* no model for now
    S(model)
  */
diff --git a/src/lib/eina/eina_promise.c b/src/lib/eina/eina_promise.c
deleted file mode 100644
index 31310c1bbe..0000000000
--- a/src/lib/eina/eina_promise.c
+++ /dev/null
@@ -1,999 +0,0 @@
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <Eina.h>
-
-#include <eina_private.h>
-
-#include <assert.h>
-
-static int _eina_promise_log_dom = -1;
-
-#ifdef ERR
-#undef ERR
-#endif
-#define ERR(...) EINA_LOG_DOM_ERR(_eina_promise_log_dom, __VA_ARGS__)
-
-#define _EINA_PROMISE_NULL_CHECK(promise, v)    \
-  if(!promise)                                  \
-    {                                           \
-      eina_error_set(EINA_ERROR_PROMISE_NULL);  \
-      return v;                                 \
-    }
-#define EINA_MAGIC_CHECK_PROMISE(promise)               \
-  do if(!EINA_MAGIC_CHECK(promise, EINA_MAGIC_PROMISE))    \
-       {EINA_MAGIC_FAIL(promise, EINA_MAGIC_PROMISE);} while(0)
-#define EINA_MAGIC_CHECK_PROMISE_OWNER(promise)               \
-  do {if(!EINA_MAGIC_CHECK(promise, EINA_MAGIC_PROMISE_OWNER))  \
-      {EINA_MAGIC_FAIL(promise, EINA_MAGIC_PROMISE_OWNER);} } while(0)
-#define EINA_PROMISE_SAFE_GET_OR_RETURN(x, y, v)                        \
-  x = eina_safepointer_get((Eina_Safepointer const*)y);                 \
-  if(!x) return v
-
-typedef struct _Eina_Promise_Then_Cb _Eina_Promise_Then_Cb;
-typedef struct _Eina_Promise_Progress_Cb _Eina_Promise_Progress_Cb;
-typedef struct _Eina_Promise_Cancel_Cb _Eina_Promise_Cancel_Cb;
-typedef struct _Eina_Promise_Owner_Progress_Notify_Data _Eina_Promise_Owner_Progress_Notify_Data;
-typedef struct _Eina_Promise_Default _Eina_Promise_Default;
-typedef struct _Eina_Promise_Default_Owner _Eina_Promise_Default_Owner;
-typedef struct _Eina_Promise_Iterator _Eina_Promise_Iterator;
-typedef struct _Eina_Promise_Success_Iterator _Eina_Promise_Success_Iterator;
-
-struct _Eina_Promise_Then_Cb
-{
-   EINA_INLIST;
-
-   Eina_Promise_Cb callback;
-   Eina_Promise_Error_Cb error_cb;
-   void* data;
-};
-
-struct _Eina_Promise_Progress_Cb
-{
-   EINA_INLIST;
-
-   Eina_Promise_Progress_Cb callback;
-   Eina_Promise_Free_Cb free;
-   void* data;
-};
-
-struct _Eina_Promise_Cancel_Cb
-{
-   EINA_INLIST;
-
-   Eina_Promise_Default_Cancel_Cb callback;
-   Eina_Promise_Free_Cb free;
-   void* data;
-};
-
-struct _Eina_Promise_Owner_Progress_Notify_Data
-{
-   EINA_INLIST;
-
-   Eina_Promise_Progress_Notify_Cb callback;
-   Eina_Promise_Free_Cb free_cb;
-   void* data;
-};
-
-struct _Eina_Promise_Default
-{
-   Eina_Promise_VTable vtable;
-   Eina_Error error;
-   size_t value_size;
-
-   Eina_Inlist *then_callbacks;
-   Eina_Inlist *progress_callbacks;
-   Eina_Inlist *cancel_callbacks;
-   Eina_Inlist *progress_notify_callbacks;
-   Eina_Promise_Free_Cb value_free_cb;
-   Eina_Promise* promise_pointer;
-
-   int ref;
-
-   Eina_Bool has_finished : 1;
-   Eina_Bool has_errored : 1;
-   Eina_Bool can_be_deleted : 1;
-   Eina_Bool is_cancelled : 1;
-   Eina_Bool is_manual_then : 1;
-   Eina_Bool is_first_then : 1;
-};
-
-struct _Eina_Promise_Default_Owner
-{
-   Eina_Promise_Owner_VTable owner_vtable;
-   _Eina_Promise_Default promise;
-   Eina_Promise_Owner* owner_pointer;
-   void* pointer_value;
-};
-
-#define EINA_PROMISE_GET_OWNER(p) (_Eina_Promise_Default_Owner*)((unsigned char*)p - offsetof(struct _Eina_Promise_Default_Owner, promise))
-
-struct _Eina_Promise_Iterator
-{
-   struct _Eina_Promise_Success_Iterator
-   {
-      Eina_Iterator success_iterator_impl;
-      unsigned int promise_index;
-      unsigned int num_promises;
-      unsigned int promises_finished;
-      Eina_Promise* promises[];
-   } data;
-};
-
-typedef struct _Eina_Promise_Race _Eina_Promise_Race;
-struct _Eina_Promise_Race
-{
-   _Eina_Promise_Default_Owner promise_default;
-   unsigned int num_promises;
-   struct _Eina_Promise_Race_Information
-   {
-      Eina_Promise* promise;
-      _Eina_Promise_Race* self;
-   } promises[];
-};
-
-static void _eina_promise_free_progress_callback_node(void* node)
-{
-   _Eina_Promise_Progress_Cb *progress_cb = node;
-   if(progress_cb->free)
-     progress_cb->free(progress_cb->data);
-   free(progress_cb);
-}
-
-static void _eina_promise_free_progress_notify_callback_node(void* node)
-{
-   _Eina_Promise_Owner_Progress_Notify_Data *progress_notify_cb = node;
-   if(progress_notify_cb->free_cb)
-     progress_notify_cb->free_cb(progress_notify_cb->data);
-   free(progress_notify_cb);
-}
-
-static void _eina_promise_free_cancel_callback_node(void *node)
-{
-    _Eina_Promise_Cancel_Cb *cancel_cb = node;
-    if (cancel_cb->free)
-      cancel_cb->free(cancel_cb->data);
-    free(cancel_cb);
-}
-
-static void _eina_promise_finish(_Eina_Promise_Default_Owner* promise);
-static void _eina_promise_ref(_Eina_Promise_Default* promise);
-static void _eina_promise_unref(_Eina_Promise_Default* promise);
-
-static void _eina_promise_iterator_setup(_Eina_Promise_Iterator* iterator, Eina_Array* promises);
-
-static void _eina_promise_free_callback_list(Eina_Inlist** list, void(*free_cb)(void* node))
-{
-  struct node
-  {
-    EINA_INLIST;
-  } *node;
-  Eina_Inlist *list2;
-  
-  EINA_INLIST_FOREACH_SAFE(*list, list2, node)
-    {
-      free_cb(node);
-    }      
-  *list = NULL;
-}
-
-static void
-_eina_promise_then_calls(_Eina_Promise_Default_Owner* promise)
-{
-   _Eina_Promise_Then_Cb* callback;
-   Eina_Bool error;
-
-   _eina_promise_ref(&promise->promise);
-   error = promise->promise.has_errored;
-
-   EINA_INLIST_FREE(promise->promise.then_callbacks, callback)
-     {
-       promise->promise.then_callbacks = eina_inlist_remove(promise->promise.then_callbacks, EINA_INLIST_GET(callback));
-       if (error)
-         {
-            if (callback->error_cb)
-              (*callback->error_cb)(callback->data, promise->promise.error);
-         }
-       else if (callback->callback)
-         {
-            (*callback->callback)(callback->data, promise->pointer_value);
-         }
-       free(callback);
-       _eina_promise_unref(&promise->promise);
-     }
-   _eina_promise_unref(&promise->promise);
-}
-
-static void
-_eina_promise_cancel_calls(_Eina_Promise_Default_Owner* promise, Eina_Bool call_cancel EINA_UNUSED)
-{
-   _Eina_Promise_Cancel_Cb* callback;
-
-   _eina_promise_ref(&promise->promise);
-   EINA_INLIST_FREE(promise->promise.cancel_callbacks, callback)
-     {
-        promise->promise.cancel_callbacks = eina_inlist_remove(promise->promise.cancel_callbacks, EINA_INLIST_GET(callback));
-        if (callback->callback)
-          {
-             (*callback->callback)(callback->data, (Eina_Promise_Owner*)promise);
-          }
-        free(callback);
-     }
-
-   if (!promise->promise.is_manual_then)
-     {
-        _eina_promise_then_calls(promise);
-     }
-   _eina_promise_unref(&promise->promise);
-}
-
-static void
-_eina_promise_del(_Eina_Promise_Default_Owner* promise)
-{
-   if (!promise->promise.has_finished)
-     {
-        ERR("Promise is being deleted, despite not being finished yet. This will cause intermitent crashes");
-     }
-
-   if (promise->promise.value_free_cb)
-     {
-        promise->promise.value_free_cb(promise->pointer_value);
-     }
-
-   _eina_promise_free_callback_list(&promise->promise.progress_callbacks,
-                                    &_eina_promise_free_progress_callback_node);
-   _eina_promise_free_callback_list(&promise->promise.progress_notify_callbacks,
-                                    &_eina_promise_free_progress_notify_callback_node);
-   _eina_promise_free_callback_list(&promise->promise.cancel_callbacks,
-                                    &_eina_promise_free_cancel_callback_node);
-
-   eina_safepointer_unregister((Eina_Safepointer const*)promise->owner_pointer);
-   eina_safepointer_unregister((Eina_Safepointer const*)promise->promise.promise_pointer);
-
-   EINA_MAGIC_SET(&promise->owner_vtable, 0xdeadbeef);
-   EINA_MAGIC_SET(&promise->promise.vtable, 0xbeefdead);
-   free(promise);
-}
-
-static void *
-_eina_promise_value_get(_Eina_Promise_Default const* p)
-{
-   _Eina_Promise_Default_Owner const* promise = EINA_PROMISE_GET_OWNER(p);
-   if (p->has_finished && !p->has_errored)
-     {
-        return promise->pointer_value;
-     }
-   else
-     {
-        return NULL;
-     }
-}
-
-static void
-_eina_promise_owner_value_set(_Eina_Promise_Default_Owner* promise, const void* data, Eina_Promise_Free_Cb free)
-{
-   promise->pointer_value = (void*)data;
-   promise->promise.value_free_cb = free;
-   _eina_promise_finish(promise);
-}
-
-static void
-_eina_promise_then(_Eina_Promise_Default* p, Eina_Promise_Cb callback,
-		   Eina_Promise_Error_Cb error_cb, void* data)
-{
-   _Eina_Promise_Default_Owner* promise;
-   _Eina_Promise_Then_Cb* cb;
-   _Eina_Promise_Owner_Progress_Notify_Data* notify_data;
-
-   promise = EINA_PROMISE_GET_OWNER(p);
-
-   cb = malloc(sizeof(struct _Eina_Promise_Then_Cb));
-
-   cb->callback = callback;
-   cb->error_cb = error_cb;
-   cb->data = data;
-   promise->promise.then_callbacks = eina_inlist_append(promise->promise.then_callbacks, EINA_INLIST_GET(cb));
-
-   EINA_INLIST_FOREACH(promise->promise.progress_notify_callbacks, notify_data)
-     {
-        (*notify_data->callback)(notify_data->data, promise->owner_pointer);
-     }
-   _eina_promise_free_callback_list(&promise->promise.progress_notify_callbacks, &free);
-   
-   if (!promise->promise.is_first_then)
-     {
-        _eina_promise_ref(p);
-     }
-   else
-     promise->promise.is_first_then = EINA_FALSE;
-   if (promise->promise.has_finished)
-     {
-        _eina_promise_then_calls(promise);
-     }
-}
-
-static void
-_eina_promise_owner_error_set(_Eina_Promise_Default_Owner* promise, Eina_Error error)
-{
-   promise->promise.error = error;
-   promise->promise.has_errored = EINA_TRUE;
-
-   _eina_promise_finish(promise);
-}
-
-static void
-_eina_promise_finish(_Eina_Promise_Default_Owner* promise)
-{
-   promise->promise.has_finished = EINA_TRUE;
-   promise->promise.can_be_deleted = EINA_TRUE;
-   if (!promise->promise.is_manual_then)
-     {
-        _eina_promise_then_calls(promise);
-     }
-}
-
-static Eina_Error
-_eina_promise_error_get(_Eina_Promise_Default const* promise)
-{
-   if (promise->has_errored)
-     {
-        return promise->error;
-     }
-   else
-     {
-        return 0;
-     }
-}
-
-static Eina_Bool
-_eina_promise_pending_is(_Eina_Promise_Default const* promise)
-{
-   return !promise->has_finished;
-}
-
-static Eina_Bool
-_eina_promise_owner_pending_is(_Eina_Promise_Default_Owner const* promise)
-{
-   return !promise->promise.has_finished;
-}
-
-static Eina_Bool
-_eina_promise_owner_cancelled_is(_Eina_Promise_Default_Owner const* promise)
-{
-   return promise->promise.is_cancelled;
-}
-
-static void
-_eina_promise_progress_cb_add(_Eina_Promise_Default* promise, Eina_Promise_Progress_Cb callback, void* data,
-                              Eina_Promise_Free_Cb free_cb)
-{
-   _Eina_Promise_Progress_Cb* cb;
-   _Eina_Promise_Owner_Progress_Notify_Data* notify_data;
-   _Eina_Promise_Default_Owner* owner = EINA_PROMISE_GET_OWNER(promise);
-
-   cb = malloc(sizeof(struct _Eina_Promise_Progress_Cb));
-   cb->callback = callback;
-   cb->data = data;
-   cb->free = free_cb;
-   promise->progress_callbacks = eina_inlist_append(promise->progress_callbacks, EINA_INLIST_GET(cb));
-   EINA_INLIST_FOREACH(owner->promise.progress_notify_callbacks, notify_data)
-     {
-       (*notify_data->callback)(notify_data->data, owner->owner_pointer);
-     }
-   _eina_promise_free_callback_list(&owner->promise.progress_notify_callbacks,
-                                    &_eina_promise_free_progress_notify_callback_node);
-}
-
-static void
-_eina_promise_cancel(_Eina_Promise_Default* promise)
-{
-   _Eina_Promise_Default_Owner* owner = EINA_PROMISE_GET_OWNER(promise);
-
-   if (!owner->promise.is_cancelled && !owner->promise.has_finished)
-     {
-        owner->promise.is_cancelled = EINA_TRUE;
-        owner->promise.has_finished = EINA_TRUE;
-        owner->promise.has_errored = EINA_TRUE;
-        owner->promise.error = EINA_ERROR_PROMISE_CANCEL;
-        _eina_promise_cancel_calls(owner, EINA_TRUE);
-     }
-}
-
-static void
-_eina_promise_ref(_Eina_Promise_Default* p)
-{
-   ++p->ref;
-}
-
-static void
-_eina_promise_unref(_Eina_Promise_Default* p)
-{
-   if (--p->ref <= 0 && p->has_finished && p->can_be_deleted)
-     {
-        _eina_promise_del(EINA_PROMISE_GET_OWNER(p));
-     }
-}
-
-static int
-_eina_promise_ref_get(_Eina_Promise_Default* p)
-{
-   return p->ref;
-}
-
-static Eina_Promise *
-_eina_promise_owner_promise_get(_Eina_Promise_Default_Owner* p)
-{
-   return p->promise.promise_pointer;
-}
-
-EAPI void
-eina_promise_owner_default_cancel_cb_add(Eina_Promise_Owner* p,
-					 Eina_Promise_Default_Cancel_Cb callback, void* data,
-					 Eina_Promise_Free_Cb free_cb)
-{
-   _Eina_Promise_Default_Owner* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, p, );
-   _Eina_Promise_Cancel_Cb *cb;
-
-   cb = malloc(sizeof(struct _Eina_Promise_Cancel_Cb));
-
-   cb->callback = callback;
-   cb->free = free_cb;
-   cb->data = data;
-   promise->promise.cancel_callbacks = eina_inlist_append(promise->promise.cancel_callbacks, EINA_INLIST_GET(cb));
-
-   if (promise->promise.is_cancelled)
-     {
-        _eina_promise_cancel_calls(promise, EINA_TRUE);
-     }
-}
-
-static void
-_eina_promise_owner_progress(_Eina_Promise_Default_Owner* promise, void* data)
-{
-   _Eina_Promise_Progress_Cb* callback;
-   Eina_Inlist* list2;
-
-   EINA_INLIST_FOREACH_SAFE(promise->promise.progress_callbacks, list2, callback)
-     {
-        if(callback->callback)
-          (*callback->callback)(callback->data, data);
-     }
-}
-
-static void
-_eina_promise_owner_progress_notify(_Eina_Promise_Default_Owner* promise, Eina_Promise_Progress_Notify_Cb notify,
-                                    void* data, Eina_Promise_Free_Cb free_cb)
-{
-   _Eina_Promise_Owner_Progress_Notify_Data* cb
-     = malloc(sizeof(struct _Eina_Promise_Owner_Progress_Notify_Data));
-
-   cb->callback = notify;
-   cb->free_cb = free_cb;
-   cb->data = data;
-   promise->promise.progress_notify_callbacks =
-     eina_inlist_append(promise->promise.progress_notify_callbacks, EINA_INLIST_GET(cb));
-}
-
-static void eina_promise_add_internal(_Eina_Promise_Default_Owner* p)
-{
-   p->promise.vtable.version = EINA_PROMISE_VERSION;
-   p->promise.vtable.then = EINA_FUNC_PROMISE_THEN(_eina_promise_then);
-   p->promise.vtable.value_get = EINA_FUNC_PROMISE_VALUE_GET(_eina_promise_value_get);
-   p->promise.vtable.error_get = EINA_FUNC_PROMISE_ERROR_GET(_eina_promise_error_get);
-   p->promise.vtable.pending_is = EINA_FUNC_PROMISE_PENDING_IS(_eina_promise_pending_is);
-   p->promise.vtable.progress_cb_add = EINA_FUNC_PROMISE_PROGRESS_CB_ADD(_eina_promise_progress_cb_add);
-   p->promise.vtable.cancel = EINA_FUNC_PROMISE_CANCEL(_eina_promise_cancel);
-   p->promise.vtable.ref = EINA_FUNC_PROMISE_REF(_eina_promise_ref);
-   p->promise.vtable.unref = EINA_FUNC_PROMISE_UNREF(_eina_promise_unref);
-   p->promise.vtable.ref_get = EINA_FUNC_PROMISE_REF_GET(_eina_promise_ref_get);
-   EINA_MAGIC_SET(&p->promise.vtable, EINA_MAGIC_PROMISE);
-
-   p->promise.is_first_then = EINA_TRUE;
-   p->promise.ref = 1;
-   p->promise.promise_pointer = eina_promise_override(&p->promise.vtable);
-
-   p->owner_vtable.version = EINA_PROMISE_VERSION;
-   p->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(_eina_promise_owner_value_set);
-   p->owner_vtable.error_set = EINA_FUNC_PROMISE_OWNER_ERROR_SET(_eina_promise_owner_error_set);
-   p->owner_vtable.promise_get = EINA_FUNC_PROMISE_OWNER_PROMISE_GET(_eina_promise_owner_promise_get);
-   p->owner_vtable.pending_is = EINA_FUNC_PROMISE_OWNER_PENDING_IS(_eina_promise_owner_pending_is);
-   p->owner_vtable.cancelled_is = EINA_FUNC_PROMISE_OWNER_CANCELLED_IS(_eina_promise_owner_cancelled_is);
-   p->owner_vtable.progress = EINA_FUNC_PROMISE_OWNER_PROGRESS(_eina_promise_owner_progress);
-   p->owner_vtable.progress_notify = EINA_FUNC_PROMISE_OWNER_PROGRESS_NOTIFY(_eina_promise_owner_progress_notify);
-   EINA_MAGIC_SET(&p->owner_vtable, EINA_MAGIC_PROMISE_OWNER);
-   p->owner_pointer = eina_promise_owner_override(&p->owner_vtable);
-}
-
-EAPI Eina_Promise_Owner *
-eina_promise_add()
-{
-   _Eina_Promise_Default_Owner* p;
-   p = calloc(sizeof(_Eina_Promise_Default_Owner), 1);
-   eina_promise_add_internal(p);   
-   return p->owner_pointer;
-}
-
-EAPI void
-eina_promise_owner_default_manual_then_set(Eina_Promise_Owner* owner, Eina_Bool is_manual)
-{
-   _Eina_Promise_Default_Owner* EINA_PROMISE_SAFE_GET_OR_RETURN(p, owner, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(&p->owner_vtable);
-
-   p->promise.is_manual_then = is_manual;
-}
-
-EAPI void
-eina_promise_owner_default_call_then(Eina_Promise_Owner* owner)
-{
-   _Eina_Promise_Default_Owner* EINA_PROMISE_SAFE_GET_OR_RETURN(p, owner, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(&p->owner_vtable);
-
-   _eina_promise_then_calls(p);
-}
-
-// eina_promise_all implementation
-static void
-_eina_promise_all_compose_then_cb(void *data, void* value EINA_UNUSED)
-{
-   _Eina_Promise_Default_Owner* promise = data;
-   _Eina_Promise_Iterator* iterator;
-   EINA_MAGIC_CHECK_PROMISE_OWNER(&promise->owner_vtable);
-
-   if (!promise->promise.has_finished)
-     {
-        iterator = promise->pointer_value;
-        if (++(iterator->data.promises_finished) == iterator->data.num_promises)
-          {
-             _eina_promise_finish(promise);
-          }
-     }
-   eina_promise_unref(promise->promise.promise_pointer);
-}
-
-static void
-_eina_promise_all_compose_error_then_cb(void *data, Eina_Error error)
-{
-   _Eina_Promise_Default_Owner* promise = data;
-   EINA_MAGIC_CHECK_PROMISE_OWNER(&promise->owner_vtable);
-
-   if (!promise->promise.has_finished)
-     {
-        promise->promise.has_finished = promise->promise.has_errored = EINA_TRUE;
-        promise->promise.error = error;
-        _eina_promise_finish(promise);
-     }
-   eina_promise_unref(promise->promise.promise_pointer);
-}
-
-static void
-_eina_promise_all_free(_Eina_Promise_Iterator* value)
-{
-   unsigned i = 0;
-
-   for (;i != value->data.num_promises; ++i)
-     {
-        eina_promise_unref(value->data.promises[i]);
-     }
-
-   free(value);
-}
-
-Eina_Promise *
-eina_promise_all(Eina_Iterator* it)
-{
-   Eina_Promise_Owner *safe_promise;
-   _Eina_Promise_Default_Owner *promise;
-   Eina_Promise* current;
-   Eina_Array* promises;
-   Eina_Promise **cur_promise, **last;
-   _Eina_Promise_Iterator* internal_it;
-
-   EINA_SAFETY_ON_NULL_RETURN_VAL(it, NULL);
-   
-   promises = eina_array_new(20);
-
-   EINA_ITERATOR_FOREACH(it, current)
-     {
-        eina_array_push(promises, current);
-     }
-
-   eina_iterator_free(it);
-
-   promise = eina_safepointer_get((Eina_Safepointer*)(safe_promise = eina_promise_add()));
-   if (!promise)
-     {
-        eina_array_free(promises);
-        return NULL;
-     }
-
-   internal_it = promise->pointer_value = malloc(sizeof(_Eina_Promise_Iterator) +
-                                                 sizeof(_Eina_Promise_Default_Owner*) * eina_array_count_get(promises));
-
-   promise->promise.value_free_cb = (Eina_Promise_Free_Cb)&_eina_promise_all_free;
-
-   _eina_promise_iterator_setup(internal_it, promises);
-
-   cur_promise = internal_it->data.promises;
-   last = internal_it->data.promises + internal_it->data.num_promises;
-   for (;cur_promise != last; ++cur_promise)
-     {
-        eina_promise_ref(*cur_promise); // We need to keep the value alive until this promise is freed
-        // We need to keep the all promise alive while there are callbacks registered to it
-        eina_promise_ref(promise->promise.promise_pointer);
-        eina_promise_then(*cur_promise, &_eina_promise_all_compose_then_cb,
-                          &_eina_promise_all_compose_error_then_cb, promise);
-     }
-
-   eina_array_free(promises);
-   return promise->promise.promise_pointer;
-}
-
-static Eina_Bool
-_eina_promise_iterator_next(_Eina_Promise_Success_Iterator *it, void **data)
-{
-   if (it->promise_index == it->num_promises)
-     return EINA_FALSE;
-
-   if (eina_promise_error_get(it->promises[it->promise_index]))
-     {
-        return EINA_FALSE;
-     }
-   else
-     {
-        *data = eina_promise_value_get(it->promises[it->promise_index++]);
-        return EINA_TRUE;
-     }
-}
-
-static void **
-_eina_promise_iterator_get_container(_Eina_Promise_Success_Iterator *it)
-{
-   return (void**)it->promises;
-}
-
-static void
-_eina_promise_iterator_free(_Eina_Promise_Success_Iterator *it EINA_UNUSED)
-{
-}
-
-static void
-_eina_promise_iterator_setup(_Eina_Promise_Iterator* it, Eina_Array* promises_array)
-{
-   Eina_Promise** promises;
-
-   it->data.num_promises = eina_array_count_get(promises_array);
-   it->data.promise_index = 0;
-   it->data.promises_finished = 0;
-   promises = (Eina_Promise**)promises_array->data;
-
-   memcpy(&it->data.promises[0], promises, it->data.num_promises*sizeof(Eina_Promise*));
-
-   EINA_MAGIC_SET(&it->data.success_iterator_impl, EINA_MAGIC_ITERATOR);
-
-   it->data.success_iterator_impl.version = EINA_ITERATOR_VERSION;
-   it->data.success_iterator_impl.next = FUNC_ITERATOR_NEXT(_eina_promise_iterator_next);
-   it->data.success_iterator_impl.get_container = FUNC_ITERATOR_GET_CONTAINER(
-      _eina_promise_iterator_get_container);
-   it->data.success_iterator_impl.free = FUNC_ITERATOR_FREE(_eina_promise_iterator_free);
-}
-
-static void
-_eina_promise_progress_notify_fulfilled(void* data, Eina_Promise_Owner* p EINA_UNUSED)
-{
-  Eina_Promise_Owner* owner = data;
-  // Make sure the promise is alive after value_set until our cleanup cp is called
-  eina_promise_ref(eina_promise_owner_promise_get(owner));
-  eina_promise_owner_value_set(owner, NULL, NULL);
-}
-
-EAPI Eina_Error EINA_ERROR_PROMISE_NO_NOTIFY;
-EAPI Eina_Error EINA_ERROR_PROMISE_CANCEL;
-EAPI Eina_Error EINA_ERROR_PROMISE_NULL;
-
-static void
-_eina_promise_progress_notify_finish(void* data)
-{
-  Eina_Promise_Owner* owner = data;
-  if(eina_promise_owner_pending_is(owner))
-    eina_promise_owner_error_set(owner, EINA_ERROR_PROMISE_NO_NOTIFY);
-  else // Cleanup the ref we got from the fulfilled cb
-    eina_promise_unref(eina_promise_owner_promise_get(owner));
-}
-
-// Race implementation
-static void _eina_promise_race_unref(_Eina_Promise_Default* promise)
-{
-   _Eina_Promise_Race* p = (void*)EINA_PROMISE_GET_OWNER(promise);
-   unsigned i;
-   if (--p->promise_default.promise.ref <= 0 && p->promise_default.promise.can_be_deleted)
-     {
-       for(i = 0; i != p->num_promises; ++i)
-         {
-           eina_promise_unref(p->promises[i].promise);
-         }
-        _eina_promise_del(&p->promise_default);
-     }
-}
-
-static void
-_eina_promise_race_compose_then_cb(void *data, void* value EINA_UNUSED)
-{
-   struct _Eina_Promise_Race_Information* info = data;
-   _Eina_Promise_Race* race_promise = info->self;
-
-   if (!race_promise->promise_default.promise.has_finished)
-     eina_promise_owner_value_set(race_promise->promise_default.owner_pointer, value, NULL);
-   eina_promise_unref(race_promise->promise_default.promise.promise_pointer);
-}
-
-static void
-_eina_promise_race_compose_error_then_cb(void *data, Eina_Error error)
-{
-   struct _Eina_Promise_Race_Information* info = data;
-   _Eina_Promise_Race* race_promise = info->self;
-
-   if (!race_promise->promise_default.promise.has_finished)
-     eina_promise_owner_error_set(race_promise->promise_default.owner_pointer, error);
-   eina_promise_unref(race_promise->promise_default.promise.promise_pointer);
-}
-
-Eina_Promise *
-eina_promise_race(Eina_Iterator* it)
-{
-   _Eina_Promise_Race *promise;
-   Eina_Promise* current;
-   Eina_Array* promises;
-   struct _Eina_Promise_Race_Information *cur_promise, *last;
-   int num_promises;
-
-   EINA_SAFETY_ON_NULL_RETURN_VAL(it, NULL);
-
-   promises = eina_array_new(20);
-
-   EINA_ITERATOR_FOREACH(it, current)
-     {
-        eina_array_push(promises, current);
-     }
-
-   eina_iterator_free(it);
-
-   num_promises = eina_array_count_get(promises);
-   promise = calloc(sizeof(_Eina_Promise_Race) + sizeof(struct _Eina_Promise_Race_Information)*num_promises, 1);
-   eina_promise_add_internal(&promise->promise_default);
-
-   promise->num_promises = num_promises;
-   promise->promise_default.promise.vtable.unref = EINA_FUNC_PROMISE_UNREF(_eina_promise_race_unref);
-
-   cur_promise = promise->promises;
-   last = promise->promises + num_promises;
-   for (int i = 0;cur_promise != last; ++cur_promise, ++i)
-     {
-        cur_promise->promise = eina_array_data_get(promises, i);
-        cur_promise->self = promise;
-        eina_promise_ref(cur_promise->promise); // We need to keep the value alive until this promise is freed
-        // We need to keep the all promise alive while there are callbacks registered to it
-        eina_promise_ref(promise->promise_default.promise.promise_pointer);
-        eina_promise_then(cur_promise->promise, &_eina_promise_race_compose_then_cb,
-                          &_eina_promise_race_compose_error_then_cb, cur_promise);
-     }
-
-   eina_array_free(promises);
-   return promise->promise_default.promise.promise_pointer;
-}
-
-// API functions
-EAPI Eina_Promise_Owner* eina_promise_owner_override(Eina_Promise_Owner_VTable* owner)
-{
-   _EINA_PROMISE_NULL_CHECK(owner, NULL);
-   EINA_MAGIC_CHECK_PROMISE_OWNER(owner);
-   Eina_Safepointer const* p = eina_safepointer_register(owner);
-   return (Eina_Promise_Owner*)p;
-}
-
-EAPI Eina_Promise* eina_promise_override(Eina_Promise_VTable* promise)
-{
-   _EINA_PROMISE_NULL_CHECK(promise, NULL);
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   Eina_Safepointer const* p = eina_safepointer_register(promise);
-   return (Eina_Promise*)p;
-}
-
-EAPI Eina_Promise*
-eina_promise_progress_notification(Eina_Promise_Owner* safe_promise)
-{
-  Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, NULL);
-  Eina_Promise_Owner* owner;
-
-  owner = eina_promise_add();
-
-  eina_promise_owner_progress_notify(safe_promise, &_eina_promise_progress_notify_fulfilled, owner,
-                                     &_eina_promise_progress_notify_finish);
-
-  return eina_promise_owner_promise_get(owner);
-}
-
-EAPI void
-eina_promise_then(Eina_Promise* safe_promise, Eina_Promise_Cb callback,
-		  Eina_Promise_Error_Cb error_cb, void* data)
-{
-   Eina_Promise_VTable* promise = eina_safepointer_get((void*)safe_promise);
-   if(!safe_promise || !promise)
-     {
-        if(!error_cb)
-          {
-            ERR("eina_promise_the with NULL promise and no error callback.");
-            eina_error_set(EINA_ERROR_PROMISE_NULL);
-          }
-        else
-          error_cb(data, EINA_ERROR_PROMISE_NULL);
-        return;
-     }
-   else
-     promise->then(promise, callback, error_cb, data);
-}
-
-EAPI void
-eina_promise_owner_value_set(Eina_Promise_Owner* safe_promise, const void* value, Eina_Promise_Free_Cb free)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   promise->value_set(promise, value, free);
-}
-
-EAPI void
-eina_promise_owner_error_set(Eina_Promise_Owner* safe_promise, Eina_Error error)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   promise->error_set(promise, error);
-}
-
-EAPI void *
-eina_promise_value_get(Eina_Promise const* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, NULL);
-   _EINA_PROMISE_NULL_CHECK(promise, NULL);
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   return promise->value_get(promise);
-}
-
-EAPI Eina_Error
-eina_promise_error_get(Eina_Promise const* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, 0);
-   _EINA_PROMISE_NULL_CHECK(promise, EINA_ERROR_PROMISE_NULL);
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   return promise->error_get(promise);
-}
-
-EAPI Eina_Bool
-eina_promise_pending_is(Eina_Promise const* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, EINA_FALSE);
-   _EINA_PROMISE_NULL_CHECK(promise, EINA_FALSE);
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   return promise->pending_is(promise);
-}
-
-EAPI void
-eina_promise_progress_cb_add(Eina_Promise* safe_promise, Eina_Promise_Progress_Cb callback, void* data,
-                             Eina_Promise_Free_Cb free_cb)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   promise->progress_cb_add(promise, callback, data, free_cb);
-}
-
-EAPI void
-eina_promise_cancel(Eina_Promise* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   promise->cancel(promise);
-}
-
-EAPI void
-eina_promise_ref(Eina_Promise* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   promise->ref(promise);
-}
-
-EAPI void
-eina_promise_unref(Eina_Promise* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   promise->unref(promise);
-}
-
-EAPI int
-eina_promise_ref_get(Eina_Promise* safe_promise)
-{
-   Eina_Promise_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, 0);
-   _EINA_PROMISE_NULL_CHECK(promise, 0);
-   EINA_MAGIC_CHECK_PROMISE(promise);
-   return promise->ref_get(promise);
-}
-
-EAPI Eina_Promise *
-eina_promise_owner_promise_get(Eina_Promise_Owner* safe_promise)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, NULL);
-   _EINA_PROMISE_NULL_CHECK(promise, NULL);
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   return promise->promise_get(promise);
-}
-
-EAPI Eina_Bool
-eina_promise_owner_pending_is(Eina_Promise_Owner const* safe_promise)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, EINA_FALSE);
-   _EINA_PROMISE_NULL_CHECK(promise, EINA_FALSE);
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   return promise->pending_is(promise);
-}
-
-EAPI Eina_Bool
-eina_promise_owner_cancelled_is(Eina_Promise_Owner const* safe_promise)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, EINA_FALSE);
-   _EINA_PROMISE_NULL_CHECK(promise, EINA_FALSE);
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   return promise->cancelled_is(promise);
-}
-
-EAPI void
-eina_promise_owner_progress(Eina_Promise_Owner const* safe_promise, void* progress)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   promise->progress(promise, progress);
-}
-
-EAPI void
-eina_promise_owner_progress_notify(Eina_Promise_Owner* safe_promise, Eina_Promise_Progress_Notify_Cb progress_cb,
-                                   void* data, Eina_Promise_Free_Cb free_cb)
-{
-   Eina_Promise_Owner_VTable* EINA_PROMISE_SAFE_GET_OR_RETURN(promise, safe_promise, );
-   _EINA_PROMISE_NULL_CHECK(promise, );
-   EINA_MAGIC_CHECK_PROMISE_OWNER(promise);
-   promise->progress_notify(promise, progress_cb, data, free_cb);
-}
-
-static const char EINA_ERROR_PROMISE_NO_NOTIFY_STR[] = "Out of memory";
-static const char EINA_ERROR_PROMISE_CANCEL_STR[] = "Promise cancelled";
-static const char EINA_ERROR_PROMISE_NULL_STR[] = "NULL promise";
-
-Eina_Bool eina_promise_init()
-{
-   EINA_ERROR_PROMISE_NO_NOTIFY = eina_error_msg_static_register(EINA_ERROR_PROMISE_NO_NOTIFY_STR);
-   EINA_ERROR_PROMISE_CANCEL = eina_error_msg_static_register(EINA_ERROR_PROMISE_CANCEL_STR);
-   EINA_ERROR_PROMISE_NULL = eina_error_msg_static_register(EINA_ERROR_PROMISE_NULL_STR);
-
-   _eina_promise_log_dom = eina_log_domain_register("eina_promise",
-                                                    EINA_LOG_COLOR_DEFAULT);
-   if (_eina_promise_log_dom < 0)
-     {
-        EINA_LOG_ERR("Could not register log domain: eina_promise");
-        return EINA_FALSE;
-     }
-
-   return EINA_TRUE;
-}
-
-Eina_Bool eina_promise_shutdown()
-{
-   eina_log_domain_unregister(_eina_promise_log_dom);
-   _eina_promise_log_dom = -1;
-   return EINA_TRUE;
-}
diff --git a/src/lib/eina/eina_promise.h b/src/lib/eina/eina_promise.h
deleted file mode 100644
index 0d6f779a34..0000000000
--- a/src/lib/eina/eina_promise.h
+++ /dev/null
@@ -1,515 +0,0 @@
-#ifndef EINA_PROMISE_H_
-#define EINA_PROMISE_H_
-
-#ifdef EFL_BETA_API_SUPPORT
-
-/*
- * @def Eina_Promise
- */
-typedef struct _Eina_Promise Eina_Promise;
-
-/*
- * @def Eina_Promise_VTable
- */
-typedef struct _Eina_Promise_VTable Eina_Promise_VTable;
-
-/*
- * @def Eina_Promise
- */
-typedef struct _Eina_Promise_Owner Eina_Promise_Owner;
-
-/*
- * @def Eina_Promise
- */
-typedef struct _Eina_Promise_Owner_VTable Eina_Promise_Owner_VTable;
-
-/*
- * @brief Callback type for freeing Promise value and void* pointer data for callbacks
- */
-typedef void(*Eina_Promise_Free_Cb)(void* value);
-
-/*
- * @brief Callback type for Promise_Owner to get notified of when someone registered a progress and/or then callback
- */
-typedef void(*Eina_Promise_Progress_Notify_Cb)(void* data, Eina_Promise_Owner* promise);
-
-/*
- * @brief Function callback type for when using eina_promise_then
- */
-typedef void(*Eina_Promise_Cb)(void* data, void* value);
-
-/*
- * @brief Function callback type for when using eina_promise_then
- */
-typedef void(*Eina_Promise_Error_Cb)(void* data, Eina_Error error);
-
-/*
- * @brief Function callback type for progress information
- */
-typedef void(*Eina_Promise_Progress_Cb)(void* data, void* value);
-
-/*
- * @brief Function callback type for then function override
- */
-typedef void(*Eina_Promise_Then_Cb)(Eina_Promise_VTable* promise, Eina_Promise_Cb callback,
-                                    Eina_Promise_Error_Cb error_cb, void* data);
-
-#define EINA_FUNC_PROMISE_THEN(Function) ((Eina_Promise_Then_Cb)Function)
-
-/*
- * @brief Function callback type for promise's value_get function override
- */
-typedef void*(*Eina_Promise_Value_Get_Cb)(Eina_Promise_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_VALUE_GET(Function) ((Eina_Promise_Value_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise's error_get function override
- */
-typedef Eina_Error(*Eina_Promise_Error_Get_Cb)(Eina_Promise_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_ERROR_GET(Function) ((Eina_Promise_Error_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise's pending function override
- */
-typedef Eina_Bool(*Eina_Promise_Pending_Is_Cb)(Eina_Promise_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_PENDING_IS(Function) ((Eina_Promise_Pending_Is_Cb)Function)
-
-/*
- * @brief Function callback type for promise's progress add function override
- */
-typedef void(*Eina_Promise_Progress_Cb_Add_Cb)(Eina_Promise_VTable* promise, Eina_Promise_Progress_Cb callback, void* data
-                                               , Eina_Promise_Free_Cb free_cb);
-
-#define EINA_FUNC_PROMISE_PROGRESS_CB_ADD(Function) ((Eina_Promise_Progress_Cb_Add_Cb)Function)
-
-/*
- * @brief Function callback type for promise's cancel function override
- */
-typedef void(*Eina_Promise_Cancel_Cb)(Eina_Promise_VTable* promise);
-
-#define EINA_FUNC_PROMISE_CANCEL(Function) ((Eina_Promise_Cancel_Cb)Function)
-
-/*
- * @brief Function callback type for promise's ref function override
- */
-typedef void(*Eina_Promise_Ref_Cb)(Eina_Promise_VTable* promise);
-
-#define EINA_FUNC_PROMISE_REF(Function) ((Eina_Promise_Ref_Cb)Function)
-
-/*
- * @brief Function callback type for promise's unref function override
- */
-typedef void(*Eina_Promise_Unref_Cb)(Eina_Promise_VTable* promise);
-
-#define EINA_FUNC_PROMISE_UNREF(Function) ((Eina_Promise_Unref_Cb)Function)
-
-/*
- * @brief Function callback type for promise's ref_get function override
- */
-typedef int(*Eina_Promise_Ref_Get_Cb)(Eina_Promise_VTable* promise);
-
-#define EINA_FUNC_PROMISE_REF_GET(Function) ((Eina_Promise_Ref_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise's buffer_get function override
- */
-typedef void*(*Eina_Promise_Buffer_Get_Cb)(Eina_Promise_VTable* promise);
-
-#define EINA_FUNC_PROMISE_BUFFER_GET(Function) ((Eina_Promise_Buffer_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's buffer_get function override
- */
-typedef void*(*Eina_Promise_Owner_Buffer_Get_Cb)(Eina_Promise_Owner_VTable* promise);
-
-#define EINA_FUNC_PROMISE_OWNER_BUFFER_GET(Function) ((Eina_Promise_Owner_Buffer_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's promise_get function override
- */
-typedef void*(*Eina_Promise_Owner_Promise_Get_Cb)(Eina_Promise_Owner_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_OWNER_PROMISE_GET(Function) ((Eina_Promise_Owner_Promise_Get_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's value_set function override
- */
-typedef void(*Eina_Promise_Owner_Value_Set_Cb)(Eina_Promise_Owner_VTable* promise, const void* data, Eina_Promise_Free_Cb free_fun);
-
-#define EINA_FUNC_PROMISE_OWNER_VALUE_SET(Function) ((Eina_Promise_Owner_Value_Set_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's error_set function override
- */
-typedef void(*Eina_Promise_Owner_Error_Set_Cb)(Eina_Promise_Owner_VTable* promise, Eina_Error error);
-
-#define EINA_FUNC_PROMISE_OWNER_ERROR_SET(Function) ((Eina_Promise_Owner_Error_Set_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's pending function override
- */
-typedef Eina_Bool(*Eina_Promise_Owner_Pending_Is_Cb)(Eina_Promise_Owner_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_OWNER_PENDING_IS(Function) ((Eina_Promise_Owner_Pending_Is_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's cancelled function override
- */
-typedef Eina_Bool(*Eina_Promise_Owner_Cancelled_Is_Cb)(Eina_Promise_Owner_VTable const* promise);
-
-#define EINA_FUNC_PROMISE_OWNER_CANCELLED_IS(Function) ((Eina_Promise_Owner_Cancelled_Is_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's progress function override
- */
-typedef Eina_Bool(*Eina_Promise_Owner_Progress_Cb)(Eina_Promise_Owner_VTable const* promise, void* progress);
-
-#define EINA_FUNC_PROMISE_OWNER_PROGRESS(Function) ((Eina_Promise_Owner_Progress_Cb)Function)
-
-/*
- * @brief Function callback type for promise owner's progress notify registration function override
- */
-typedef Eina_Bool(*Eina_Promise_Owner_Progress_Notify_Cb)(Eina_Promise_Owner_VTable* promise,
-   Eina_Promise_Progress_Notify_Cb progress_cb, void* data, Eina_Promise_Free_Cb free_cb);
-
-#define EINA_FUNC_PROMISE_OWNER_PROGRESS_NOTIFY(Function) ((Eina_Promise_Owner_Progress_Notify_Cb)Function)
-
-
-#define EINA_PROMISE_VERSION 1
-
-struct _Eina_Promise_VTable
-{
-  int version;
-  Eina_Promise_Then_Cb then;
-  Eina_Promise_Value_Get_Cb value_get;
-  Eina_Promise_Error_Get_Cb error_get;
-  Eina_Promise_Pending_Is_Cb pending_is;
-  Eina_Promise_Progress_Cb_Add_Cb progress_cb_add;
-  Eina_Promise_Cancel_Cb cancel;
-  Eina_Promise_Ref_Cb ref;
-  Eina_Promise_Unref_Cb unref;
-  Eina_Promise_Ref_Get_Cb ref_get;
-#define EINA_MAGIC_PROMISE 0x07932A5B
-  EINA_MAGIC;
-};
-
-struct _Eina_Promise_Owner_VTable
-{
-  int version;
-  Eina_Promise_Owner_Value_Set_Cb value_set;
-  Eina_Promise_Owner_Error_Set_Cb error_set;
-  Eina_Promise_Owner_Promise_Get_Cb promise_get;
-  Eina_Promise_Owner_Pending_Is_Cb pending_is;
-  Eina_Promise_Owner_Cancelled_Is_Cb cancelled_is;
-  Eina_Promise_Owner_Progress_Cb progress;
-  Eina_Promise_Owner_Progress_Notify_Cb progress_notify;
-#define EINA_MAGIC_PROMISE_OWNER 0x07932A5C
-  EINA_MAGIC;
-};
-
-EAPI Eina_Promise_Owner* eina_promise_owner_override(Eina_Promise_Owner_VTable* owner);
-
-EAPI Eina_Promise* eina_promise_override(Eina_Promise_VTable* owner);
-
-/*
- * @brief Appends a callback to be called when the Eina_Promise is
- * finished.
- *
- * @param promise The Eina_Promise to wait for
- * @param callback Callback to be called when Eina_Promise is finished
- * @param data Private data passed to the callback
- */
-EAPI void eina_promise_then(Eina_Promise* promise, Eina_Promise_Cb callback,
-                            Eina_Promise_Error_Cb error_cb, void* data);
-
-/*
- * @brief Creates a new @Eina_Promise from other @Eina_Promise's
- *
- * The new @Eina_Promise is fulfilled when all promises
- * have also been fulfilled with success or when the
- * first one fails
- *
- * @param promises An Eina_Iterator for all Eina_Promises
- * @return Returns a new Eina_Promise
- */
-EAPI Eina_Promise* eina_promise_all(Eina_Iterator* promises);
-
-/*
- * @brief Creates a new @Eina_Promise from other @Eina_Promises
- *
- * The new @Eina_Promise is fulfilled when the first promise
- * has been fulfilled with success or when the
- * first one fails
- *
- * @param promises An Eina_Iterator for all Eina_Promises
- * @return Returns a new Eina_Promise
- */
-EAPI Eina_Promise* eina_promise_race(Eina_Iterator* promises);
-
-/*
- * @brief Creates a new @Eina_Promise from another @Eina_Promise_Owner which
- * is fulfilled when @promise has a progress callback registered
- *
- * @param promise Promise Owner which to be waited for a progress callback register
- * @return Returns a new Eina_Promise
- */
-EAPI Eina_Promise* eina_promise_progress_notification(Eina_Promise_Owner* promise);
-
-/*
- * @brief Sets value for Eina_Promise_Owner
- *
- * This finishes the Promise and calls all eina_promise_then callbacks
- * that have been registered on Eina_Promise. This function must be
- * called only once per Eina_Promise_Owner
- *
- * @param promise The promise owner for which to set the value
- * @param value The pointer to the value that is going to be copied, or NULL.
- * @param free_cb Callback function to be used to free the value copied
- */
-EAPI void eina_promise_owner_value_set(Eina_Promise_Owner* promise, const void* value, Eina_Promise_Free_Cb free_cb);
-
-/*
- * @brief Returns the pointer to the value
- *
- * If the Eina_Promise is not pending anymore and has not failed,
- * returns the pointer to the value, otherwise returns NULL.
- *
- * @param promise The promise for which to get the value
- * @return Value pointer or @NULL
- */
-EAPI void* eina_promise_value_get(Eina_Promise const* promise);
-
-/*
- * @brief Sets an error to the Eina_Promise
- *
- * Sets an error to the promise, finishing the promise and calling all
- * eina_promise_then callbacks registered.
- *
- * @param promise The promise owner for which to set the error
- * @param error Eina_Error to be set
- */
-EAPI void eina_promise_owner_error_set(Eina_Promise_Owner* promise, Eina_Error error);
-
-/*
- * @brief Gets the error of the @Eina_Promise
- * 
- * If the promise is finished and has been set with an error, it
- * retuns the @Eina_Error, otherwise returns 0.
- *
- * @param promise The promise for which to get the error
- * @return @Eina_Error set in @Eina_Promise
- */
-EAPI Eina_Error eina_promise_error_get(Eina_Promise const* promise);
-
-/*
- * @brief Returns @EINA_TRUE if the promise is still pending and
- * still waiting on a value to be set and @EINA_FALSE otherwise.
- *
- * @param promise The promise for which to get the pending status
- * @return Returns @EINA_TRUE if the promise is still pending and
- * still waiting on a value to be set and @EINA_FALSE otherwise.
- */
-EAPI Eina_Bool eina_promise_pending_is(Eina_Promise const* promise);
-
-/*
- * @brief Adds a progress callback that is called by the asynchronous
- * call to inform of any progress made.
- *
- * @param promise The promise for which to register a progress callback
- * @param progress The callback to be called when progress is made
- * @param data The private data that will be passed to the progress callback
- */
-EAPI void eina_promise_progress_cb_add(Eina_Promise* promise, Eina_Promise_Progress_Cb progress, void* data,
-                                       Eina_Promise_Free_Cb free_cb);
-
-/*
- * @brief Increments the reference count for the Eina_Promise
- *
- * @param promise The promise for which to increment its reference
- */
-EAPI void eina_promise_ref(Eina_Promise* promise);
-
-/*
- * @brief Cancel asynchronous operation, if possible.
- *
- * @param promise The promise to cancel
- */
-EAPI void eina_promise_cancel(Eina_Promise* promise);
-
-/*
- * @brief Gets Promise from Promise_Owner
- *
- * This function returns an @Eina_Promise from an
- * @Eina_Promise_Owner. The user of the asynchronous operation can
- * query the value from the @Eina_Promise object, while the
- * asynchronous operation should use the @Eina_Promise_Owner object to
- * set the value, or error, and thus finish the promise.
- *
- * @param promise The promise owner to get promise from.
- * @return Return the @Eina_Promise
- */
-EAPI Eina_Promise* eina_promise_owner_promise_get(Eina_Promise_Owner* promise);
-
-/*
- * @brief Returns @EINA_TRUE if the promise is still pending and
- * still waiting on a value to be set and @EINA_FALSE otherwise.
- *
- * @param promise The promise owner for which to get the pending status
- * @return Returns @EINA_TRUE if the promise is still pending and
- * still waiting on a value to be set and @EINA_FALSE otherwise.
- */
-EAPI Eina_Bool eina_promise_owner_pending_is(Eina_Promise_Owner const* promise);
-
-/*
- * @brief Returns @EINA_TRUE if the promise was cancelled
- * or @EINA_FALSE otherwise.
- *
- * @param promise The promise owner for which to get the cancelled status
- * @return Returns @EINA_TRUE if the promise was cancelled
- * or @EINA_FALSE otherwise.
- */
-EAPI Eina_Bool eina_promise_owner_cancelled_is(Eina_Promise_Owner const* promise);
-
-/*
- * @brief Calls progress callbacks in promise, if any exists, with
- * the data.
- *
- * The progress callbacks registered in @Eina_Promise must not free
- * the progress data pointer. The data pointer ownership must be dealt
- * by the @Eina_Promise_Owner's user.
- *
- * @param promise The promise for which to get the cancelled status
- * @param data    The data to be passed to progress
- */
-EAPI void eina_promise_owner_progress(Eina_Promise_Owner const* promise, void* progress);
-
-/*
- * @brief Registers a progress notify callbacks in promise owner.
- *
- * Registers a callback to be called for when a progress callback is
- * registered by the linked @Eina_Promise.
- *
- * @param promise   The promise for which to get the cancelled status
- * @param notify_cb The callback to be called
- * @param data      The data to be passed to progress notify callback
- * @param free_cb   The free function that is called for the data param
- */
-EAPI void eina_promise_owner_progress_notify(Eina_Promise_Owner* promise,
-    Eina_Promise_Progress_Notify_Cb notify_cb, void* data, Eina_Promise_Free_Cb free_cb);
-  
-/*
- * @brief Decrement the reference count for the Eina_Promise.
-
- * The Eina_Promise, if its reference count drops to zero and is not
- * pending, will be free'd immediately.
- *
- * @param promise The promise for which to decrement its reference
- */
-EAPI void eina_promise_unref(Eina_Promise* promise);
-
-/*
- * @brief Get the reference count for the Eina_Promise.
-
- * @param promise The promise for which to get its reference
- */
-EAPI int eina_promise_ref_get(Eina_Promise* promise);
-
-/*
- * @brief Function callback type when promise is canceled
- */
-typedef void(*Eina_Promise_Default_Cancel_Cb)(void* data, Eina_Promise_Owner* promise);
-
-/*
- * @brief Creates a @Eina_Promise_Owner
- *
- * Create a @Eina_Promise_Owner for a pointer-type. Which is a promise
- * with ownership of the pointer when its value is set.  The Promise
- * itself, returned by eina_promise_owner_promise_get, represents the
- * asynchronicity of the value itself and is used solely to get the
- * value and to handle users of the asynchronous value. That's why
- * Promises have a reference count while Promise Owners do not, the
- * eina_promise_owner_value_set must be done only once, and
- * consequently, has a unique ownership of the owner lifetime, while
- * the promise can be queried and used by multiple users.
- *
- * @return @Eina_Promise_Owner just instantiated
- */
-EAPI Eina_Promise_Owner* eina_promise_add();
-
-/*
- * @brief Adds a cancel callback to be called when the promise is
- * canceled by the usuer
- *
- * @param promise The promise for which to register a cancel callback
- */
-EAPI void eina_promise_owner_default_cancel_cb_add(
-            Eina_Promise_Owner* promise, Eina_Promise_Default_Cancel_Cb cancel, void* data,
-            Eina_Promise_Free_Cb free_cb);
-
-/*
- * @brief Commands the @Eina_Promise_Owner not to call the then
- * callbacks automatically
- *
- * @param promise The promise for which to register a cancel callback
- */
-EAPI void eina_promise_owner_default_manual_then_set(Eina_Promise_Owner* promise, Eina_Bool is_manual);
-
-/*
- * @brief Calls the @Eina_Promise_Owner's then callbacks already registered
- *
- * @param promise The promise for which to register a cancel callback
- */
-EAPI void eina_promise_owner_default_call_then(Eina_Promise_Owner* promise);
-
-/**
- * @var EINA_ERROR_PROMISE_NO_NOTIFY
- *
- * @brief The error identifier corresponding to when a promise was
- * free'd before any progress callback was registered
- */
-EAPI extern Eina_Error EINA_ERROR_PROMISE_NO_NOTIFY;
-
-/**
- * @var EINA_ERROR_PROMISE_CANCEL
- *
- * @brief The error identifier corresponding to when a promise was
- * cancelled before the callback can be called
- */
-EAPI extern Eina_Error EINA_ERROR_PROMISE_CANCEL;
-
-/**
- * @var EINA_ERROR_PROMISE_NULL
- *
- * @brief The error identifier corresponding to when a promise function
- * is called on a NULL promise
- */
-EAPI extern Eina_Error EINA_ERROR_PROMISE_NULL;
-
-/*
- * @internal
- */
-#define _EINA_PROMISE_BEFORE_HOOK(PromiseValue, Ret, ...)               \
-  Eina_Promise_Owner* const __eo_promise = eina_promise_add();          \
-  typedef Ret (*_Eo_Promise_func_t_)(Eo*, void *obj_data, ##__VA_ARGS__); \
-  _Eo_Promise_func_t_ const _eo_promise_func_ = (_Eo_Promise_func_t_)_func_;
-
-/*
- * @internal
- */
-#define _EINA_PROMISE_CALL_HOOK(Arguments)                      \
-  _eo_promise_func_(___call.eo_id, ___call.data, Arguments);
-
-
-/*
- * @internal
- */
-#define _EINA_PROMISE_AFTER_HOOK(Promise)                               \
-  if(Promise)                                                           \
-    *Promise = eina_promise_owner_promise_get(__eo_promise);
-
-#endif
-
-#endif /* ! EINA_PROMISE_H_ */