eina_init();
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+ Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
eina_promise_ref(promise);
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+ Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
eina_promise_then(promise, &cb, NULL, NULL);
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+ Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
struct value_type* v = eina_promise_owner_buffer_get(owner);
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+ Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
struct value_type* v = eina_promise_owner_buffer_get(owner);
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+ Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
eina_promise_then(promise, &cb, NULL, NULL);
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
- struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
- = malloc(sizeof(struct value_type));
+ struct value_type* p = malloc(sizeof(struct value_type));
p->x = p->y = p->w = p->h = 0;
eina_promise_then(promise, &pointer_cb, NULL, NULL);
- eina_promise_owner_value_set(owner, NULL, &indirect_free);
+ eina_promise_owner_value_set(owner, p, &indirect_free);
}
/* Suppress warnings as we really don't want to do anything. */
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
- struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
- = malloc(sizeof(struct value_type));
+ struct value_type* p = malloc(sizeof(struct value_type));
p->x = p->y = p->w = p->h = 0;
- eina_promise_owner_value_set(owner, NULL, &indirect_free);
+ eina_promise_owner_value_set(owner, p, &indirect_free);
eina_promise_then(promise, &pointer_cb, NULL, NULL);
}
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
- struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
- = eina_mempool_malloc(mempool, sizeof(struct value_type));
+ struct value_type* p = eina_mempool_malloc(mempool, sizeof(struct value_type));
p->x = p->y = p->w = p->h = 0;
eina_promise_then(promise, &pointer_cb, NULL, NULL);
- eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+ eina_promise_owner_value_set(owner, p, &indirect_mempool_free);
}
/* Suppress warnings as we really don't want to do anything. */
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
- struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
- = eina_mempool_malloc(mempool, sizeof(struct value_type));
+ struct value_type* p = eina_mempool_malloc(mempool, sizeof(struct value_type));
p->x = p->y = p->w = p->h = 0;
- eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+ eina_promise_owner_value_set(owner, p, &indirect_mempool_free);
eina_promise_then(promise, &pointer_cb, NULL, NULL);
}
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
struct value_type v = {0,0,0,0};
- *(struct value_type**)eina_promise_owner_buffer_get(owner) = &v;
eina_promise_then(promise, &pointer_cb, NULL, NULL);
- eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+ eina_promise_owner_value_set(owner, &v, NULL);
}
/* Suppress warnings as we really don't want to do anything. */
for (j = 0; j != 200; ++j)
for (i = 0; i != request; ++i)
{
- Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+ Eina_Promise_Owner* owner = eina_promise_add();
Eina_Promise* promise = eina_promise_owner_promise_get(owner);
struct value_type v = {0,0,0,0};
- *(struct value_type**)eina_promise_owner_buffer_get(owner) = &v;
- eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+ eina_promise_owner_value_set(owner, &v, NULL);
eina_promise_then(promise, &pointer_cb, NULL, NULL);
}
Eina_Bool is_prop = (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET);
Eina_Bool has_promise = EINA_FALSE;
+ Eina_Bool is_pointer_promise = EINA_FALSE;
const char* promise_param_name = NULL;
const char* promise_value_type = NULL;
Eina_Bool need_implementation = EINA_TRUE;
promise_values = eolian_type_subtypes_get(ptypet);
Eolian_Type* subtype;
if(eina_iterator_next(promise_values, (void**)&subtype))
+ {
promise_value_type = eolian_type_c_type_get(subtype);
+ is_pointer_promise = eolian_type_type_get(subtype) == EOLIAN_TYPE_POINTER
+ || eolian_type_type_get(subtype) == EOLIAN_TYPE_COMPLEX;
+ }
eina_strbuf_append_printf(impl_full_params, ", Eina_Promise_Owner *%s%s",
pname, is_empty && !dflt_value ?" EINA_UNUSED":"");
eina_strbuf_append_printf(params, "__eo_promise");
{
eina_strbuf_append_printf(fbody,
"#undef _EO_API_BEFORE_HOOK\n#undef _EO_API_AFTER_HOOK\n#undef _EO_API_CALL_HOOK\n"
- "#define _EO_API_BEFORE_HOOK _EINA_PROMISE_BEFORE_HOOK(%s, %s%s)\n"
+ "#define _EO_API_BEFORE_HOOK _EINA_PROMISE_%sBEFORE_HOOK(%s, %s%s)\n"
"#define _EO_API_AFTER_HOOK _EINA_PROMISE_AFTER_HOOK(%s)\n"
"#define _EO_API_CALL_HOOK(x) _EINA_PROMISE_CALL_HOOK(EO_FUNC_CALL(%s))\n\n",
+ (is_pointer_promise? "POINTER_": ""),
promise_value_type, !rettype ? "void" : rettype,
eina_strbuf_string_get(impl_full_params),
promise_param_name,
*/
EAPI Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_heavy,
Ecore_Thread_Promise_Cb func_cancel,
- const void* data, size_t value_size,
+ const void* data,
Eina_Promise** promise);
#endif
{
Efl_Internal_Promise *j = data;
- eina_promise_owner_value_set(j->promise, &j->data, NULL);
+ eina_promise_owner_value_set(j->promise, j->data, NULL);
free(j);
}
{
Efl_Internal_Promise *t = data;
- eina_promise_owner_value_set(t->promise, &t->data, NULL);
+ eina_promise_owner_value_set(t->promise, t->data, NULL);
eo_del(t->u.timer);
Efl_Internal_Promise *j;
Eina_Promise_Owner *promise;
- promise = eina_promise_default_add(sizeof (void*));
+ promise = eina_promise_add();
if (!promise) return NULL;
j = _efl_internal_promise_new(promise, data);
Efl_Internal_Promise *t;
Eina_Promise_Owner *promise;
- promise = eina_promise_default_add(sizeof (void*));
+ promise = eina_promise_add();
if (!promise) return NULL;
t = _efl_internal_promise_new(promise, data);
_Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise);
return v->eina_promise->value_size_get(v->eina_promise);
}
-static void* _ecore_promise_release_value_ownership(Eina_Promise* promise)
-{
- _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise);
- return v->eina_promise->release_value_ownership(v->eina_promise);
-}
Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_blocking,
Ecore_Thread_Promise_Cb func_cancel,
- const void* data, size_t value_size,
+ const void* data,
Eina_Promise** promise)
{
_Ecore_Thread_Promise_Owner* priv;
priv = malloc(sizeof(_Ecore_Thread_Promise_Owner));
- priv->eina_owner = eina_promise_default_add(value_size);
+ priv->eina_owner = eina_promise_add();
priv->owner_vtable.version = EINA_PROMISE_VERSION;
priv->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(&_ecore_promise_owner_value_set);
priv->promise_vtable.unref = EINA_FUNC_PROMISE_UNREF(&_ecore_promise_unref);
priv->promise_vtable.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(&_ecore_promise_value_size_get);
priv->promise_vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(&_ecore_promise_buffer_get);
- priv->promise_vtable.release_value_ownership = EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP
- (&_ecore_promise_release_value_ownership);
priv->thread_callback_data.data = data;
priv->thread_callback_data.func_blocking = func_blocking;
Eina_Bool is_cancelled : 1;
Eina_Bool is_manual_then : 1;
Eina_Bool is_first_then : 1;
+ Eina_Bool is_pointer : 1;
};
struct _Eina_Promise_Default_Owner
struct _Eina_Promise_Iterator
{
- Eina_Iterator* success_iterator;
struct _Eina_Promise_Success_Iterator
{
Eina_Iterator success_iterator_impl;
}
else if (callback->callback)
{
- (*callback->callback)(callback->data, &promise->value[0], &promise->promise.vtable);
+ if(promise->promise.is_pointer)
+ {
+ char* buffer = promise->value;
+ void** p = (void**)buffer;
+ (*callback->callback)(callback->data, *p, &promise->promise.vtable);
+ }
+ else
+ (*callback->callback)(callback->data, &promise->value[0], &promise->promise.vtable);
}
free(callback);
_eina_promise_unref(&promise->promise);
}
if (promise->promise.value_free_cb)
- promise->promise.value_free_cb((void*)&promise->value[0]);
+ {
+ if(promise->promise.is_pointer)
+ {
+ char* buffer = promise->value;
+ void** p = (void**)buffer;
+ promise->promise.value_free_cb(*p);
+ }
+ else
+ promise->promise.value_free_cb((void*)&promise->value[0]);
+ }
_eina_promise_free_callback_list(&promise->promise.progress_callbacks,
&_eina_promise_free_progress_callback_node);
}
static void *
+_eina_promise_owner_pointer_buffer_get(_Eina_Promise_Default_Owner* promise)
+{
+ char* buffer = promise->value;
+ void** p = (void**)buffer;
+ return *p;
+}
+
+static void *
_eina_promise_buffer_get(_Eina_Promise_Default const* promise)
{
_Eina_Promise_Default_Owner const* p = EINA_PROMISE_GET_OWNER(promise);
}
static void *
-_eina_promise_release_value_ownership(_Eina_Promise_Default* p)
+_eina_promise_pointer_value_get(_Eina_Promise_Default const* p)
{
- _Eina_Promise_Default_Owner* promise = EINA_PROMISE_GET_OWNER(p);
+ _Eina_Promise_Default_Owner const* promise = EINA_PROMISE_GET_OWNER(p);
if (p->has_finished && !p->has_errored)
{
- p->value_free_cb = NULL;
- return (void*)&promise->value[0];
+ char const* buffer = promise->value;
+ void** p = (void**)buffer;
+ return *p;
}
else
{
}
static void
+_eina_promise_owner_pointer_value_set(_Eina_Promise_Default_Owner* promise, const void* data, Eina_Promise_Free_Cb free)
+{
+ char* buffer = promise->value;
+ void** p = (void**)buffer;
+ *p = (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_Owner *
-eina_promise_default_add(int value_size)
+eina_promise_value_add(int value_size)
{
_Eina_Promise_Default_Owner* p;
p->promise.vtable.unref = EINA_FUNC_PROMISE_UNREF(_eina_promise_unref);
p->promise.vtable.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(_eina_promise_value_size_get);
p->promise.vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(_eina_promise_buffer_get);
- p->promise.vtable.release_value_ownership = EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP(_eina_promise_release_value_ownership);
p->promise.has_finished = p->promise.has_errored =
- p->promise.is_cancelled = p->promise.is_manual_then = EINA_FALSE;
+ p->promise.is_cancelled = p->promise.is_manual_then = p->promise.is_pointer = EINA_FALSE;
p->promise.is_first_then = EINA_TRUE;
p->promise.ref = 1;
memset(&p->promise.then_callbacks, 0, sizeof(p->promise.then_callbacks));
return &p->owner_vtable;
}
+EAPI Eina_Promise_Owner *
+eina_promise_add()
+{
+ _Eina_Promise_Default_Owner* p;
+
+ p = malloc(sizeof(_Eina_Promise_Default_Owner) + sizeof(void*));
+ 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_pointer_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.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(_eina_promise_value_size_get);
+ p->promise.vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(_eina_promise_buffer_get);
+ p->promise.has_finished = p->promise.has_errored =
+ p->promise.is_cancelled = p->promise.is_manual_then = EINA_FALSE;
+ p->promise.is_first_then = p->promise.is_pointer = EINA_TRUE;
+ p->promise.ref = 1;
+ memset(&p->promise.then_callbacks, 0, sizeof(p->promise.then_callbacks));
+ memset(&p->promise.progress_callbacks, 0, sizeof(p->promise.progress_callbacks));
+ memset(&p->promise.progress_notify_callbacks, 0, sizeof(p->promise.progress_notify_callbacks));
+ memset(&p->promise.cancel_callbacks, 0, sizeof(p->promise.cancel_callbacks));
+ p->promise.value_size = 0;
+ p->promise.value_free_cb = NULL;
+ p->promise.error = 0;
+
+ p->owner_vtable.version = EINA_PROMISE_VERSION;
+ p->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(_eina_promise_owner_pointer_value_set);
+ p->owner_vtable.error_set = EINA_FUNC_PROMISE_OWNER_ERROR_SET(_eina_promise_owner_error_set);
+ p->owner_vtable.buffer_get = EINA_FUNC_PROMISE_OWNER_BUFFER_GET(_eina_promise_owner_pointer_buffer_get);
+ p->owner_vtable.value_size_get = EINA_FUNC_PROMISE_OWNER_VALUE_SIZE_GET(_eina_promise_owner_value_size_get);
+ 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);
+
+ return &p->owner_vtable;
+}
+
void
eina_promise_owner_default_manual_then_set(Eina_Promise_Owner* owner, Eina_Bool is_manual)
{
{
unsigned i = 0;
- eina_iterator_free(value->success_iterator);
-
for (;i != value->data.num_promises; ++i)
{
eina_promise_unref(value->data.promises[i]);
eina_iterator_free(it);
promise = (_Eina_Promise_Default_Owner*)
- eina_promise_default_add(sizeof(_Eina_Promise_Iterator) +
- sizeof(_Eina_Promise_Default_Owner*)*eina_array_count_get(promises));
+ eina_promise_value_add(sizeof(_Eina_Promise_Iterator) +
+ sizeof(_Eina_Promise_Default_Owner*)*eina_array_count_get(promises));
internal_it = (_Eina_Promise_Iterator*)&promise->value[0];
_eina_promise_iterator_setup(internal_it, promises);
eina_array_free(promises);
{
Eina_Promise** promises;
- it->success_iterator = &it->data.success_iterator_impl;
it->data.num_promises = eina_array_count_get(promises_array);
it->data.promise_index = 0;
it->data.promises_finished = 0;
{
Eina_Promise_Owner* owner;
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
eina_promise_owner_progress_notify(promise, &_eina_promise_progress_notify_fulfilled, owner,
&_eina_promise_progress_notify_failed);
num_promises = eina_array_count_get(promises);
promise = (_Eina_Promise_Default_Owner*)
- eina_promise_default_add(sizeof(_Eina_Promise_Race_Value_Type) +
- sizeof(struct _Eina_Promise_Race_Information)*num_promises);
+ eina_promise_value_add(sizeof(_Eina_Promise_Race_Value_Type) +
+ sizeof(struct _Eina_Promise_Race_Information)*num_promises);
value = eina_promise_owner_buffer_get((Eina_Promise_Owner*)promise);
value->value = NULL;
value->promise_index = -1;
return promise->buffer_get(promise);
}
-EAPI void *
-eina_promise_release_value_ownership(Eina_Promise* promise)
-{
- return promise->release_value_ownership(promise);
-}
-
EAPI size_t
eina_promise_value_size_get(Eina_Promise const* promise)
{
#define EINA_FUNC_PROMISE_BUFFER_GET(Function) ((Eina_Promise_Buffer_Get_Cb)Function)
/*
- * @brief Function callback type for promise's release_value_ownership function override
- */
-typedef void*(*Eina_Promise_Release_Value_Ownership_Cb)(Eina_Promise* promise);
-
-#define EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP(Function) ((Eina_Promise_Release_Value_Ownership_Cb)Function)
-
-/*
* @brief Function callback type for promise's value_size_get function override
*/
typedef size_t(*Eina_Promise_Value_Size_Get_Cb)(Eina_Promise const* promise);
Eina_Promise_Unref_Cb unref;
Eina_Promise_Value_Size_Get_Cb value_size_get;
Eina_Promise_Buffer_Get_Cb buffer_get;
- Eina_Promise_Release_Value_Ownership_Cb release_value_ownership;
#define EINA_MAGIC_PROMISE 0x07932A5B
EINA_MAGIC;
};
EAPI void* eina_promise_buffer_get(Eina_Promise* promise);
/*
- * @brief Returns the pointer to the value and releases ownership of
- * the value by the promise.
- *
- * @param promise The promise for which to release value ownership
- * @return Pointer to value
- */
-EAPI void* eina_promise_release_value_ownership(Eina_Promise* promise);
-
-/*
* @brief Returns the pointer to the buffer that holds the value.
*
* This function always return the buffer pointer independently if the
* @param value_size Size of value-type that Eina_Promise will hold
* @return @Eina_Promise_Owner just instantiated
*/
-EAPI Eina_Promise_Owner* eina_promise_default_add(int value_size);
+EAPI Eina_Promise_Owner* eina_promise_value_add(int value_size);
+
+/*
+ * @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
* @internal
*/
#define _EINA_PROMISE_BEFORE_HOOK(PromiseValue, Ret, ...) \
- Eina_Promise_Owner* const __eo_promise = eina_promise_default_add(sizeof(PromiseValue)); \
+ Eina_Promise_Owner* const __eo_promise = eina_promise_value_add(sizeof(PromiseValue)); \
+ 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_;
+
+#define _EINA_PROMISE_POINTER_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_;
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
_job_direct_ls_helper(&eio_file_direct_ls, obj, pd, path, promise);
return eina_promise_owner_promise_get(promise);
}
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
_job_direct_ls_helper(&eio_file_stat_ls, obj, pd, path, promise);
return eina_promise_owner_promise_get(promise);
}
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
_job_direct_ls_helper(&eio_dir_stat_ls, obj, pd, path, promise);
return eina_promise_owner_promise_get(promise);
}
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
// Had to add the cast as dir_direct differs in the filter callback constness of one of
// its arguments.
_job_direct_ls_helper((Eio_Job_Direct_Ls_Func)&eio_dir_direct_ls, obj, pd, path, promise);
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eina_Stat));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(Eina_Stat));
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
Eio_Job_Data *pd,
const char *path)
{
- Eina_Promise_Owner *promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner *promise = eina_promise_value_add(sizeof(int));
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
unsigned int xattr_size,
Eina_Xattr_Flags flags)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
const char *path,
const char *attribute)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eio_Xattr_Data));
+ Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(Eio_Xattr_Data));
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
return p;
}
-/* Eina_File mapping and handling. */
-static void
-_eina_file_close(void* file)
-{
- eina_file_close(*(Eina_File**)file);
-}
-
static void
_file_open_open_cb(void *data, Eio_File *handler EINA_UNUSED, Eina_File *file)
{
Job_Closure *operation = data;
EINA_SAFETY_ON_NULL_RETURN(operation);
EINA_SAFETY_ON_NULL_RETURN(operation->promise);
- // FIXME On promise composition, a successfully open file would leak open
- // another promise in the composition fails as there is no free/close
- // function. Calling eina_file_close blocks on a lock_take call on a
- // field of the Eina_File file.
- eina_promise_owner_value_set(operation->promise, &file, &_eina_file_close);
+ eina_promise_owner_value_set(operation->promise, file, (Eina_Promise_Free_Cb)&eina_file_close);
_job_closure_del(operation);
}
const char *path,
Eina_Bool shared)
{
- Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eina_File*));
+ Eina_Promise_Owner* promise = eina_promise_add();
Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
Eina_Promise* p = eina_promise_owner_promise_get(promise);
{
EINA_SAFETY_ON_NULL_RETURN(data);
Job_Closure *operation = data;
- Eina_Bool result = EINA_TRUE;
- eina_promise_owner_value_set(operation->promise, &result, NULL);
+ eina_promise_owner_value_set(operation->promise, NULL, NULL);
_job_closure_del(operation);
}
eina_value_flush(prop_value);
eina_value_copy(value, prop_value);
- eina_promise_owner_value_set(promise, prop_value, NULL);
+ eina_value_copy(value, eina_promise_owner_buffer_get(promise));
+ eina_promise_owner_value_set(promise, NULL, (Eina_Promise_Free_Cb)&eina_value_flush);
}
static void
if (pd->is_listed)
{
Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
- eina_promise_owner_value_set(promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+ eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
return;
}
EINA_LIST_FOREACH(pd->children_promises, i, p)
{
Eina_Accessor *ac = efl_model_list_slice(pd->children_list, p->start, p->count);
- eina_promise_owner_value_set(p->promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+ eina_promise_owner_value_set(p->promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
free(p);
}
eina_list_free(pd->children_promises);
static char *_eldbus_model_object_concatenate_path(const char *, const char *);
static void _eldbus_model_object_create_children(Eldbus_Model_Object_Data *, Eldbus_Object *, Eina_List *);
-void
-_accessor_free(void *data)
-{
- Eina_Accessor **ac = data;
- eina_accessor_free(*ac);
-}
-
static Eo_Base*
_eldbus_model_object_eo_base_constructor(Eo *obj, Eldbus_Model_Object_Data *pd)
{
if (pd->is_listed)
{
Eina_Accessor* ac = efl_model_list_slice(pd->children_list, start, count);
- eina_promise_owner_value_set(promise, &ac, &_accessor_free);
+ eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
return;
}
EINA_LIST_FOREACH(pd->children_promises, i, p)
{
Eina_Accessor* ac = efl_model_list_slice(pd->children_list, p->start, p->count);
- eina_promise_owner_value_set(p->promise, &ac, &_accessor_free);
+ eina_promise_owner_value_set(p->promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
free(p);
}
eina_list_free(pd->children_promises);
Eina_Promise_Owner* promise;
};
-void _accessor_free(void *data);
-
/* logging support */
extern int eldbus_model_log_dom;
}
Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
- eina_promise_owner_value_set(promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+ eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
}
static void
static void
-_efl_promise_then_widget(Elm_View_Form_Widget *w, Eina_Value *value, Eina_Promise* promise EINA_UNUSED)
+_efl_promise_then_widget(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
{
+ Elm_View_Form_Widget *w = data;
+ Eina_Value *value = v;
w->widget_obj_set_cb(w->widget_obj, value, w->widget_propname);
}
}
static void
-_efl_model_promise_then_cb(Elm_View_Form_Promise *p, Eina_Value *value, Eina_Promise* promise EINA_UNUSED)
+_efl_model_promise_then_cb(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
{
- EINA_SAFETY_ON_NULL_RETURN(p);
-
+ Elm_View_Form_Promise *p = data;
+ Eina_Value *value = v;
Elm_View_Form_Data *priv = p->priv;
Elm_View_Form_Widget *w = NULL;
Eina_List *l = NULL;
+ EINA_SAFETY_ON_NULL_RETURN(p);
+
EINA_LIST_FOREACH(priv->widgets, l, w)
{
if (!strcmp(w->widget_propname, p->property_name))
}
static void
-_efl_model_promise_error_cb(Elm_View_Form_Promise *p, Eina_Error error EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
+_efl_model_promise_error_cb(void* data, Eina_Error error EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
{
+ Elm_View_Form_Promise *p = data;
EINA_SAFETY_ON_NULL_RETURN(p);
eina_stringshare_del(p->property_name);
p->property_name = eina_stringshare_add(prop);
p->priv = priv;
efl_model_property_get(priv->model_obj, prop, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_efl_model_promise_then_cb,
- (Eina_Promise_Error_Cb)&_efl_model_promise_error_cb, p);
+ eina_promise_then(promise, &_efl_model_promise_then_cb,
+ &_efl_model_promise_error_cb, p);
}
return EINA_TRUE;
EINA_LIST_FOREACH(priv->widgets, l, w)
{
efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_efl_promise_then_widget, &_efl_promise_error_widget, w);
+ eina_promise_then(promise, &_efl_promise_then_widget, &_efl_promise_error_widget, w);
}
}
if (priv->model_obj != NULL)
{
efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_efl_promise_then_widget,
- &_efl_promise_error_widget, priv);
+ eina_promise_then(promise, &_efl_promise_then_widget,
+ &_efl_promise_error_widget, priv);
}
return EINA_TRUE;
}
}
static void
-_property_get_cb(View_List_ValueItem *vitem, Eina_Value *value)
+_property_get_cb(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
{
+ View_List_ValueItem *vitem = data;
+ Eina_Value *value = v;
vitem->value = eina_value_new(eina_value_type_get(value));
eina_value_copy(value, vitem->value);
}
static void
-_property_get_error_cb(View_List_ValueItem *vitem, const Eina_Error *err EINA_UNUSED)
+_property_get_error_cb(void* data, Eina_Error err EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
{
+ View_List_ValueItem *vitem = data;
eina_stringshare_del(vitem->part);
}
vitem->item = idata->item;
idata->values = eina_list_append(idata->values, vitem);
efl_model_property_get(idata->model, prop, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_property_get_cb,
- (Eina_Promise_Error_Cb)&_property_get_error_cb, vitem);
+ eina_promise_then(promise, &_property_get_cb,
+ &_property_get_error_cb, vitem);
}
else
{
}
static void
-_efl_model_load_children_then(View_List_ItemData *pdata, Eina_Accessor **accessor)
+_efl_model_load_children_then(void * data, void* value, Eina_Promise* promise EINA_UNUSED)
{
+ View_List_ItemData *pdata = data;
+ Eina_Accessor *accessor = value;
Eo *child;
unsigned i = 0;
EINA_SAFETY_ON_NULL_RETURN(pdata);
EINA_SAFETY_ON_NULL_RETURN(pdata->priv);
- EINA_SAFETY_ON_NULL_RETURN(*accessor);
+ EINA_SAFETY_ON_NULL_RETURN(accessor);
Elm_View_List_Data *priv = pdata->priv;
- EINA_ACCESSOR_FOREACH(*accessor, i, child)
+ EINA_ACCESSOR_FOREACH(accessor, i, child)
{
View_List_ItemData *idata = calloc(1, sizeof(View_List_ItemData));
EINA_SAFETY_ON_NULL_RETURN(idata);
Eina_Promise *promise;
efl_model_children_slice_get(pdata->model, 0, 0, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_efl_model_load_children_then, NULL, pdata);
+ eina_promise_then(promise, &_efl_model_load_children_then, NULL, pdata);
}
static Eina_Bool
{
Eina_Bool *bob = data;
- fail_if(data != *(Eina_Bool**)value);
+ fail_if(data != value);
*bob = EINA_TRUE;
ecore_main_loop_quit();
}
START_TEST(ecore_test_job_promise)
{
Eina_Bool bob = EINA_FALSE;
- Eina_Promise *job = NULL;
ecore_init();
- job = efl_loop_job(ecore_main_loop_get(), &bob);
- eina_promise_then(job, &_ecore_promise_quit, NULL, &bob);
+ eina_promise_then(efl_loop_job(ecore_main_loop_get(), &bob), &_ecore_promise_quit, NULL, &bob);
ecore_main_loop_begin();
ecore_init();
- ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &promise);
+ ecore_thread_promise_run(&promised_thread, NULL, NULL, &promise);
eina_promise_then(promise, &promise_callback, NULL, NULL);
ecore_main_loop_begin();
ecore_init();
- ecore_thread_promise_run(&promise_error_thread, NULL, NULL, 0, &promise);
+ ecore_thread_promise_run(&promise_error_thread, NULL, NULL, &promise);
eina_promise_then(promise, NULL, &promise_error_callback, NULL);
ecore_main_loop_begin();
ecore_init();
- ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &first[0]);
+ ecore_thread_promise_run(&promised_thread, NULL, NULL, &first[0]);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
eina_promise_then(promise, &promise_callback, NULL, NULL);
int i = 0;
- ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &first[0]);
+ ecore_thread_promise_run(&promised_thread, NULL, NULL, &first[0]);
eina_promise_then(first[0], &promise_callback2, NULL, &i);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
eina_promise_then(promise, &promise_callback2, NULL, &i);
eina_lock_new(&data.lock);
eina_condition_new(&data.cond, &data.lock);
- thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, 0, &promise);
+ thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, &promise);
eina_lock_take(&data.lock);
while(!data.var)
eina_lock_new(&data.lock);
eina_condition_new(&data.cond, &data.lock);
- thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, 0, &first[0]);
+ thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, &first[0]);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
eina_lock_take(&data.lock);
}
END_TEST
-void promised_block_thread(const void* data EINA_UNUSED, Eina_Promise_Owner* promise, Ecore_Thread* thread EINA_UNUSED)
-{
- struct timespec v = {.tv_sec = 1, .tv_nsec = 0}, rem;
- if(nanosleep(&v, &rem) == -1 && errno == EINTR)
- do
- {
- v = rem;
- }
- while(nanosleep(&v, &rem) == -1 && errno == EINTR);
-
- int r = 10;
- eina_promise_owner_value_set(promise, &r, NULL);
-}
+/* void promised_block_thread(const void* data EINA_UNUSED, Eina_Promise_Owner* promise, Ecore_Thread* thread EINA_UNUSED) */
+/* { */
+/* struct timespec v = {.tv_sec = 1, .tv_nsec = 0}, rem; */
+/* if(nanosleep(&v, &rem) == -1 && errno == EINTR) */
+/* do */
+/* { */
+/* v = rem; */
+/* } */
+/* while(nanosleep(&v, &rem) == -1 && errno == EINTR); */
+
+/* int r = 10; */
+/* eina_promise_owner_value_set(promise, &r, NULL); */
+/* } */
static void
_ecore_test_promise_normal_lifetime_cb(void* data EINA_UNUSED, void* value EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
ecore_init();
- promise_owner = eina_promise_default_add(0);
+ promise_owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(promise_owner);
ecore_init();
- promise_owner = eina_promise_default_add(0);
+ promise_owner = eina_promise_value_add(0);
first[0] = eina_promise_owner_promise_get(promise_owner);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
ecore_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(owner);
eina_promise_owner_value_set(owner, NULL, NULL);
ecore_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
first[0] = eina_promise_owner_promise_get(owner);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
eina_lock_new(&v.lock);
eina_condition_new(&v.condvar, &v.lock);
- ecore_thread_promise_run(&promise_cancel_thread, &_cancel_callback, &v, 0, &promise);
+ ecore_thread_promise_run(&promise_cancel_thread, &_cancel_callback, &v, &promise);
eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL);
eina_promise_cancel(promise);
ecore_init();
- ecore_thread_promise_run(&promise_progress_thread, NULL, NULL, 0, &promise);
+ ecore_thread_promise_run(&promise_progress_thread, NULL, NULL, &promise);
eina_promise_progress_cb_add(promise, &_progress_callback, NULL, NULL);
_ecore_promise_quit(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
{
Eina_Bool *bob = data;
- double *start = *(double**)value;
+ double *start = value;
double delta = ecore_loop_time_get() - *start;
fail_if(delta - 0.2 > 0.01);
eina_init();
- promise_owner = eina_promise_default_add(0);
+ promise_owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(promise_owner);
eina_init();
- promise_owner = eina_promise_default_add(0);
+ promise_owner = eina_promise_value_add(0);
first[0] = eina_promise_owner_promise_get(promise_owner);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(owner);
eina_promise_owner_value_set(owner, NULL, NULL);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
first[0] = eina_promise_owner_promise_get(owner);
promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
static void _eina_test_promise_value_all_cb(void* data, void* value, Eina_Promise* promise EINA_UNUSED)
{
- Eina_Iterator** iterator = value;
+ Eina_Iterator* iterator = value;
int *i, *j;
Eina_Bool b;
- b = eina_iterator_next(*iterator, (void**)&i);
+ b = eina_iterator_next(iterator, (void**)&i);
ck_assert(!!b);
- b = eina_iterator_next(*iterator, (void**)&j);
+ b = eina_iterator_next(iterator, (void**)&j);
ck_assert(!!b);
ck_assert(i != NULL);
int i = 10, j = 15;
- owners[0] = eina_promise_default_add(sizeof(int));
- owners[1] = eina_promise_default_add(sizeof(int));
+ owners[0] = eina_promise_value_add(sizeof(int));
+ owners[1] = eina_promise_value_add(sizeof(int));
promises[0] = eina_promise_owner_promise_get(owners[0]);
promises[1] = eina_promise_owner_promise_get(owners[1]);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
eina_promise_owner_default_cancel_cb_add(owner, &cancel_callback, &cancel_ran, NULL);
promise = eina_promise_owner_promise_get(owner);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(owner);
eina_promise_progress_cb_add(promise, &progress_callback, &progress_ran, NULL);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
promise = eina_promise_owner_promise_get(owner);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
promise = eina_promise_owner_promise_get(owner);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
promise_progress = eina_promise_progress_notification(owner);
eina_promise_then(promise_progress, &_eina_promise_progress_notify_fulfilled,
&_eina_promise_progress_notify_error, &progress_notify_ran);
eina_init();
- owner = eina_promise_default_add(0);
+ owner = eina_promise_value_add(0);
promise = eina_promise_owner_promise_get(owner);
eina_promise_unref(promise);
eina_promise_owner_value_set(owner, NULL, NULL);
eina_init();
- promise_owner = eina_promise_default_add(0);
+ promise_owner = eina_promise_value_add(0);
+ first[0] = eina_promise_owner_promise_get(promise_owner);
+ promise = eina_promise_race(eina_carray_iterator_new((void**)&first[0]));
+
+ eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+ eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+// pointers
+START_TEST(eina_test_pointer_promise_normal_lifetime)
+{
+ Eina_Promise_Owner* promise_owner;
+ Eina_Promise* promise;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ promise_owner = eina_promise_add();
+
+ promise = eina_promise_owner_promise_get(promise_owner);
+
+ eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+ eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_normal_lifetime_all)
+{
+ Eina_Promise_Owner* promise_owner;
+ Eina_Promise* first[2] = {NULL, NULL};
+ Eina_Promise* promise;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ promise_owner = eina_promise_add();
+ first[0] = eina_promise_owner_promise_get(promise_owner);
+ promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
+
+ eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+ eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_immediate_set_lifetime)
+{
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ promise = eina_promise_owner_promise_get(owner);
+
+ eina_promise_owner_value_set(owner, NULL, NULL);
+ eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_immediate_set_lifetime_all)
+{
+ Eina_Promise_Owner* owner;
+ Eina_Promise* first[2] = {NULL, NULL};
+ Eina_Promise* promise;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ first[0] = eina_promise_owner_promise_get(owner);
+ promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
+
+ eina_promise_owner_value_set(owner, NULL, NULL);
+ eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_values_all)
+{
+ Eina_Promise_Owner* owners[2];
+ Eina_Promise* promises[3] = {NULL, NULL, NULL};
+ Eina_Promise* promise_all;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ int* i = malloc(sizeof(int)), *j = malloc(sizeof(int));
+ *i = 10;
+ *j = 15;
+
+ owners[0] = eina_promise_add();
+ owners[1] = eina_promise_add();
+
+ promises[0] = eina_promise_owner_promise_get(owners[0]);
+ promises[1] = eina_promise_owner_promise_get(owners[1]);
+
+
+ promise_all = eina_promise_all(eina_carray_iterator_new((void**)&promises[0]));
+
+ eina_promise_owner_value_set(owners[0], i, free);
+ eina_promise_owner_value_set(owners[1], j, free);
+
+ eina_promise_then(promise_all, &_eina_test_promise_value_all_cb, NULL, &ran);
+
+ ck_assert(ran == EINA_TRUE);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_cancel_promise)
+{
+ Eina_Bool ran = EINA_FALSE, cancel_ran = EINA_FALSE;
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ eina_promise_owner_default_cancel_cb_add(owner, &cancel_callback, &cancel_ran, NULL);
+
+ promise = eina_promise_owner_promise_get(owner);
+
+ eina_promise_then(promise, NULL, &_cancel_promise_callback, &ran);
+
+ eina_promise_cancel(promise);
+
+ ck_assert(cancel_ran && ran);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress)
+{
+ Eina_Bool progress_ran = EINA_FALSE;
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+ int i = 1;
+
+ eina_init();
+
+ owner = eina_promise_add();
+
+ promise = eina_promise_owner_promise_get(owner);
+ eina_promise_progress_cb_add(promise, &progress_callback, &progress_ran, NULL);
+
+ eina_promise_owner_progress(owner, &i);
+
+ ck_assert(progress_ran);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify1)
+{
+ Eina_Bool progress_notify_ran = EINA_FALSE;
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
+
+ promise = eina_promise_owner_promise_get(owner);
+ eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+ eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+
+ ck_assert(progress_notify_ran);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify2)
+{
+ Eina_Bool progress_notify_ran = EINA_FALSE;
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
+
+ promise = eina_promise_owner_promise_get(owner);
+ eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL); // never run
+ eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL); // never run
+
+ ck_assert(progress_notify_ran);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify3)
+{
+ Eina_Bool progress_notify_ran = EINA_FALSE;
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+ Eina_Promise* promise_progress;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ promise_progress = eina_promise_progress_notification(owner);
+ eina_promise_then(promise_progress, &_eina_promise_progress_notify_fulfilled,
+ &_eina_promise_progress_notify_error, &progress_notify_ran);
+
+ promise = eina_promise_owner_promise_get(owner);
+ eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+ eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+
+ ck_assert(progress_notify_ran);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_ignored)
+{
+ Eina_Promise_Owner* owner;
+ Eina_Promise* promise;
+
+ eina_init();
+
+ owner = eina_promise_add();
+ promise = eina_promise_owner_promise_get(owner);
+ eina_promise_unref(promise);
+ eina_promise_owner_value_set(owner, NULL, NULL);
+
+ eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_race)
+{
+ Eina_Promise_Owner* promise_owner;
+ Eina_Promise* first[2] = {NULL, NULL};
+ Eina_Promise* promise;
+ Eina_Bool ran = EINA_FALSE;
+
+ eina_init();
+
+ promise_owner = eina_promise_add();
first[0] = eina_promise_owner_promise_get(promise_owner);
promise = eina_promise_race(eina_carray_iterator_new((void**)&first[0]));
tcase_add_test(tc, eina_test_promise_progress_notify3);
tcase_add_test(tc, eina_test_promise_ignored);
tcase_add_test(tc, eina_test_promise_race);
+ // pointer
+ tcase_add_test(tc, eina_test_pointer_promise_normal_lifetime);
+ tcase_add_test(tc, eina_test_pointer_promise_normal_lifetime_all);
+ tcase_add_test(tc, eina_test_pointer_promise_immediate_set_lifetime);
+ tcase_add_test(tc, eina_test_pointer_promise_immediate_set_lifetime_all);
+ tcase_add_test(tc, eina_test_pointer_promise_values_all);
+ tcase_add_test(tc, eina_test_pointer_promise_cancel_promise);
+ tcase_add_test(tc, eina_test_pointer_promise_progress);
+ tcase_add_test(tc, eina_test_pointer_promise_progress_notify1);
+ tcase_add_test(tc, eina_test_pointer_promise_progress_notify2);
+ tcase_add_test(tc, eina_test_pointer_promise_progress_notify3);
+ tcase_add_test(tc, eina_test_pointer_promise_ignored);
+ tcase_add_test(tc, eina_test_pointer_promise_race);
}
}
static void
-_done_cb(void *data, Eio_File *handler EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
+_done_cb(void *data, void* value EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
{
int *number_of_listed_files = (int *)data;
fail_if((*number_of_listed_files) != test_count);
}
static void
-_open_done_cb(void *data, Eina_File **file, Eina_Promise* promise)
+_open_done_cb(void *data, void *file_value, Eina_Promise* promise EINA_UNUSED)
{
Eina_Bool *opened = (Eina_Bool *)data;
*opened = EINA_TRUE;
- eina_promise_release_value_ownership(promise);
- eina_file_close(*file);
+ Eina_File* file = eina_file_dup(file_value);
+ eina_file_close(file);
ecore_main_loop_quit();
}
static void
-_stat_done_cb(void *data, const Eina_Stat *stat, Eina_Promise* promise EINA_UNUSED)
+_stat_done_cb(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
{
- Eina_Bool *is_dir = (Eina_Bool *)data;
+ Eina_Stat const* stat = value;
+ Eina_Bool *is_dir = data;
unsigned int rights;
fail_if(eio_file_is_dir(stat) != *is_dir);
fail_if(eio_file_is_lnk(stat));
promise = ls_func(job, test_dirname);
test_count = expected_test_count;
eina_promise_progress_cb_add(promise, progress_cb, &main_files, NULL);
- eina_promise_then(promise,
- (Eina_Promise_Cb)&_done_cb,
- (Eina_Promise_Error_Cb)&_error_cb,
- &main_files);
+ eina_promise_then(promise, &_done_cb, &_error_cb, &main_files);
ecore_main_loop_begin();
const char *test_dirname)
{
_do_ls_test(ls_func,
- EIO_JOB_EVENT_FILTER_DIRECT,
- (Eo_Event_Cb)&_filter_direct_cb,
- (Eina_Promise_Progress_Cb)&_main_direct_cb,
- expected_test_count,
- test_dirname);
+ EIO_JOB_EVENT_FILTER_DIRECT,
+ (Eo_Event_Cb)&_filter_direct_cb,
+ (Eina_Promise_Progress_Cb)&_main_direct_cb,
+ expected_test_count,
+ test_dirname);
}
START_TEST(eio_job_test_file_direct_stat)
is_dir = EINA_TRUE;
promise = eio_job_file_direct_stat(job, nested_dirname);
- eina_promise_then(promise, (Eina_Promise_Cb)&_stat_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &is_dir);
+ eina_promise_then(promise, &_stat_done_cb, &_error_cb, &is_dir);
ecore_main_loop_begin();
is_dir = EINA_FALSE;
promise = eio_job_file_direct_stat(job, nested_filename);
- eina_promise_then(promise, (Eina_Promise_Cb)&_stat_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &is_dir);
+ eina_promise_then(promise, &_stat_done_cb, &_error_cb, &is_dir);
ecore_main_loop_begin();
eo_unref(job);
// Start testing
- fprintf(stderr, __FILE__ ":%d %s\n", __LINE__, __func__); fflush(stderr);
_do_ls_test(&eio_job_file_ls,
EIO_JOB_EVENT_FILTER_NAME,
(Eo_Event_Cb)&_filter_cb,
(Eina_Promise_Progress_Cb)&_main_cb,
5,
test_dirname);
- fprintf(stderr, __FILE__ ":%d %s\n", __LINE__, __func__); fflush(stderr);
_do_direct_ls_test(&eio_job_file_stat_ls, 5, test_dirname);
ret = ecore_init();
fail_if(ret < 1);
- ret = eio_init();
- fail_if(ret < 1);
ret = eina_init();
fail_if(ret < 1);
ret = ecore_file_init();
fail_if(ret < 1);
+ ret = eio_init();
+ fail_if(ret < 1);
Eina_Tmpstr *test_dirname = get_eio_test_file_tmp_dir();
Eina_Tmpstr *nested_dirname = create_test_dirs(test_dirname);
Eina_Promise *promise = NULL;
promise = eio_job_file_open(job, nested_filename, EINA_FALSE);
- eina_promise_then(promise, (Eina_Promise_Cb)&_open_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &opened_file);
+ eina_promise_then(promise, &_open_done_cb, &_error_cb, &opened_file);
ecore_main_loop_begin();
eo_unref(job);
fail_if(!opened_file);
eina_tmpstr_del(nested_dirname);
eina_tmpstr_del(test_dirname);
+
+ eio_shutdown();
eina_tmpstr_del(nested_filename);
ecore_file_shutdown();
eina_shutdown();
- eio_shutdown();
ecore_shutdown();
}
END_TEST
#include "eldbus_suite.h"
static void
-_promise_then_quit_cb(void **data , void **value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_quit_cb(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
{
- *data = *value;
+ *(void**)data = value;
ecore_main_loop_quit();
}
static void
-_promise_then_quit_u_cb(unsigned *data , unsigned *value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_quit_u_cb(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
{
- *data = *value;
+ unsigned *lhs = data;
+ unsigned *rhs = value;
+ *lhs = *rhs;
ecore_main_loop_quit();
}
static void
-_promise_then_cp(Eina_Value *data , void *value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_cp(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
{
eina_value_copy(value, data);
ecore_main_loop_quit();
efl_model_promise_then(Eina_Promise *promise)
{
void *data = NULL;
- eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_quit_cb, &_error_then_cb, &data);
+ eina_promise_then(promise, &_promise_then_quit_cb, &_error_then_cb, &data);
ecore_main_loop_begin();
return data;
}
efl_model_promise_then_u(Eina_Promise *promise)
{
unsigned i = 0;
- eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_quit_u_cb, &_error_then_cb, &i);
+ eina_promise_then(promise, &_promise_then_quit_u_cb, &_error_then_cb, &i);
ecore_main_loop_begin();
return i;
}
efl_model_property_get(efl_model, property, &promise);
ck_assert_ptr_ne(NULL, promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_cp, &_error_then_cb, &property_value);
+ eina_promise_then(promise, &_promise_then_cp, &_error_then_cb, &property_value);
ecore_main_loop_begin();
const Eina_Value_Type *property_type = eina_value_type_get(&property_value);
eina_value_set(&eina_value, value);
efl_model_property_set(efl_model, property, &eina_value, &promise);
- eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_cp, &_error_then_cb, &value_ret);
+ eina_promise_then(promise, &_promise_then_cp, &_error_then_cb, &value_ret);
ecore_main_loop_begin();
const Eina_Value_Type *property_type = eina_value_type_get(&value_ret);
projects / platform / upstream / efl.git / commitdiff