eio: first convertion to new future/promise.

src/lib/eio/efl_io_manager.c

@@ -434,7 +434,37 @@ _efl_io_manager_xattr_ls(Eo *obj,
    return NULL;
 }
 
-static Efl_Future *
+static void
+_future_file_done_cb(void *data, Eio_File *handler)
+{
+   Eina_Promise *p = data;
+   Eina_Value v = EINA_VALUE_EMPTY;
+
+   eina_value_setup(&v, EINA_VALUE_TYPE_UINT64);
+   eina_value_set(&v, handler->length);
+   eina_promise_resolve(p, v);
+}
+
+static void
+_future_file_error_cb(void *data,
+                      Eio_File *handler EINA_UNUSED,
+                      int error)
+{
+   Eina_Promise *p = data;
+   Eina_Value v = EINA_VALUE_EMPTY;
+
+   eina_value_setup(&v, EINA_VALUE_TYPE_ERROR);
+   eina_value_set(&v, error);
+   eina_promise_resolve(p, v);
+}
+
+static void
+_efl_io_manager_future_cancel(void *data, const Eina_Promise *dead_ptr EINA_UNUSED)
+{
+   eio_file_cancel(data);
+}
+
+static Eina_Future *
 _efl_io_manager_xattr_set(Eo *obj,
                           Efl_Io_Manager_Data *pd EINA_UNUSED,
                           const char *path,
@@ -442,28 +472,29 @@ _efl_io_manager_xattr_set(Eo *obj,
                           Eina_Binbuf *data,
                           Eina_Xattr_Flags flags)
 {
-   Efl_Promise *p;
+   Eina_Promise *p;
+   Eina_Future *future;
    Eio_File *h;
 
-   Eo *loop = efl_loop_get(obj);
-   p = efl_add(EFL_PROMISE_CLASS, loop);
+   p = eina_promise_new(efl_loop_future_scheduler_get(obj),
+                        _efl_io_manager_future_cancel, NULL);
    if (!p) return NULL;
+   future = eina_future_new(p);
 
    h = eio_file_xattr_set(path, attribute,
                           (const char *) eina_binbuf_string_get(data),
                           eina_binbuf_length_get(data),
                           flags,
-                          _file_done_cb,
-                          _file_error_cb,
+                          _future_file_done_cb,
+                          _future_file_error_cb,
                           p);
    if (!h) goto end;
+   eina_promise_data_set(p, h);
 
-   efl_event_callback_array_add(p, promise_handling(), h);
-   return efl_promise_future_get(p);
+   return efl_future_Eina_FutureXXX_then(obj, future);
 
  end:
-   efl_del(p);
-   return NULL;
+   return future;
 }
 
 static Efl_Future *

src/lib/eio/efl_io_manager.eo

@@ -63,7 +63,7 @@ class Efl.Io.Manager (Efl.Loop_User)
             data: ptr(Eina.Binbuf); [[Data to set as information]]
             flags: Eina.Xattr.Flags; [[Extended attributes flags]]
          }
-         return: future<uint64>; [[Future for asynchronous set operation]]
+         return: own(ptr(Eina.Future)); [[Future for asynchronous set operation]]
       }
       get {
          return: future<Eina.Binbuf>; [[Information]]

src/tests/eio/eio_test_manager_xattr.c

@@ -117,6 +117,39 @@ _error_cb(void *data EINA_UNUSED, const Efl_Event *ev)
    ecore_main_loop_quit();
 }
 
+static Eina_Value
+_future_all_cb(const void *data,
+               const Eina_Value array,
+               const Eina_Future *dead EINA_UNUSED)
+{
+   Eina_Error err;
+   unsigned int i, len;
+   int *num_of_attr = (int *)data;
+
+   if (array.type == EINA_VALUE_TYPE_ERROR)
+     {
+        eina_value_get(&array, &err);
+        fprintf(stderr, "Something has gone wrong: %s\n", eina_error_msg_get(err));
+        abort();
+     }
+   len = eina_value_array_count(&array);
+   for (i = 0; i < len; i++)
+     {
+        Eina_Value v;
+
+        eina_value_array_get(&array, i, &v);
+        if (v.type == EINA_VALUE_TYPE_ERROR)
+          {
+             eina_value_get(&v, &err);
+             fprintf(stderr, "Something has gone wrong: %s\n", eina_error_msg_get(err));
+             abort();
+          }
+     }
+
+   fail_if(*num_of_attr != len);
+   return array;
+}
+
 START_TEST(eio_test_job_xattr_set)
 {
    char *filename = "eio-tmpfile";
@@ -125,7 +158,7 @@ START_TEST(eio_test_job_xattr_set)
    unsigned int i;
    Eo *job;
    Efl_Future *ls = NULL;
-   Efl_Future **futures = NULL;
+   Eina_Future **futures = NULL;
 
    ecore_init();
    eina_init();
@@ -139,8 +172,8 @@ START_TEST(eio_test_job_xattr_set)
              S_IRWXU | S_IRWXG | S_IRWXO);
    fail_if(fd == 0);
 
-   futures = calloc(total_attributes + 1, sizeof(Efl_Future*));
-   futures[total_attributes] = NULL;
+   futures = calloc(total_attributes + 1, sizeof(Eina_Future*));
+   futures[total_attributes] = EINA_FUTURE_SENTINEL;
 
    for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i)
      {
@@ -152,8 +185,8 @@ START_TEST(eio_test_job_xattr_set)
 
         fail_if(num_of_attr != 0); // test asynchronous
      }
-   efl_future_then(efl_future_iterator_all(eina_carray_iterator_new((void**) futures)),
-                   _done_set_cb, _error_cb, NULL, &num_of_attr);
+   eina_future_then(eina_future_all_array(futures),
+                    _future_all_cb, &num_of_attr);
 
    ecore_main_loop_begin();