dimmus
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

efl: Move promise parameter to return in data model 

Summary:
Instead of:

efl_model_property_get("name", &promise);

now:

promise = efl_model_property_get("name");

Reviewers: stefan_schmidt, cedric

Subscribers: jpeg

Differential Revision: https://phab.enlightenment.org/D4038
This commit is contained in:
Felipe Magno de Almeida 2016-06-16 21:50:37 -03:00
parent 52e2774523
commit 8e4f383d61
21 changed files with 194 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/lib/efl/interfaces/efl_model.eo
View File

@ -62,8 +62,8 @@ interface Efl.Model ()
]]
params {
@in property: string; [[Property name]]
@inout value: promise<generic_value>; [[Promise of the value that was got]]
}
return: promise<generic_value>; [[Promise of the value that was got]]
}
children_slice_get {
[[Get children slice OR full range.
@ -96,8 +96,8 @@ interface Efl.Model ()
count are 0 slice is ignored.]]
@in count: uint; [[Range size. If count and start are 0 slice is
ignored.]]
@inout promise: promise<accessor<list<Eo.Base> > >; [[Promise of the children]]
}
return: promise<accessor<Eo.Base> >; [[Promise of the children]]
}
children_count_get {
[[Get children count.
@ -112,9 +112,7 @@ interface Efl.Model ()
@since 1.14
]]
params {
@inout promise: promise<uint>;
}
return: promise<uint>;
}
child_add {
[[Add a new child.

35
src/lib/eio/eio_model.c
View File

@ -288,18 +288,20 @@ _eio_model_efl_model_properties_get(Eo *obj EINA_UNUSED, Eio_Model_Data *_pd)
/**
* Property Get
*/
static void
_eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property, Eina_Promise_Owner *promise)
static Eina_Promise*
_eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property)
{
_Eio_Property_Name property_name;
const char* value = NULL;
EINA_SAFETY_ON_NULL_RETURN(priv);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
EINA_SAFETY_ON_NULL_RETURN_VAL(priv, rpromise);
if (property == NULL)
{
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
return;
return rpromise;
}
if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_FILENAME], property) == 0)
@ -321,7 +323,7 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
if (value == NULL)
{
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
return;
return rpromise;
}
property_name = EIO_MODEL_PROP_MIME_TYPE;
}
@ -336,7 +338,7 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
else
{
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
return;
return rpromise;
}
switch(property_name)
@ -362,6 +364,7 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
}
break;
}
return rpromise;
}
/**
@ -417,12 +420,15 @@ _eio_model_efl_model_property_set(Eo *obj EINA_UNUSED,
/**
* Children Count Get
*/
static void
_eio_model_efl_model_children_count_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eina_Promise_Owner *promise)
static Eina_Promise*
_eio_model_efl_model_children_count_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv)
{
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
unsigned int *c = calloc(sizeof(unsigned int), 1);
*c = eina_list_count(priv->children_list);
eina_promise_owner_value_set(promise, c, free);
return rpromise;
}
static void
@ -596,10 +602,12 @@ _eio_model_efl_model_child_del(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eo *ch
/**
* Children Slice Get
*/
static void
static Eina_Promise*
_eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv,
unsigned start, unsigned count, Eina_Promise_Owner *promise)
unsigned int start, unsigned int count)
{
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
/**
* children must be already loaded otherwise we do nothing
* and parameter is set to NULL.
@ -607,7 +615,7 @@ _eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *pri
if (!priv->path)
{
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_INIT_FAILED);
return;
return rpromise;
}
if (!(priv->is_listed))
@ -627,11 +635,12 @@ _eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *pri
_eio_main_children_load_cb, _eio_done_children_load_cb,
_eio_error_children_load_cb, priv);
}
return;
return rpromise;
}
Eina_Accessor* accessor = efl_model_list_slice(priv->children_list, start, count);
eina_promise_owner_value_set(promise, accessor, (Eina_Promise_Free_Cb)&eina_accessor_free);
return rpromise;
}

37
src/lib/eldbus/eldbus_model_arguments.c
View File

@ -123,17 +123,17 @@ _eldbus_model_arguments_efl_model_property_set(Eo *obj EINA_UNUSED,
Eina_Value *prop_value;
Eina_Value *promise_value;
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
DBG("(%p): property=%s", obj, property);
_eldbus_model_arguments_properties_load(pd);
Eina_Bool ret = _eldbus_model_arguments_is_input_argument(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, );
prop_value = eina_hash_find(pd->properties_hash, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(prop_value, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(prop_value, promise, EFL_MODEL_ERROR_NOT_FOUND, );
eina_value_flush(prop_value);
eina_value_copy(value, prop_value);
@ -143,29 +143,30 @@ _eldbus_model_arguments_efl_model_property_set(Eo *obj EINA_UNUSED,
eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
}
static void
static Eina_Promise*
_eldbus_model_arguments_efl_model_property_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Arguments_Data *pd,
const char *property,
Eina_Promise_Owner *promise)
const char *property)
{
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
Eina_Value *promise_value;
EINA_SAFETY_ON_NULL_RETURN(promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
DBG("(%p): property=%s", obj, property);
_eldbus_model_arguments_properties_load(pd);
Eina_Value* value = eina_hash_find(pd->properties_hash, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
Eina_Bool ret = _eldbus_model_arguments_is_output_argument(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_PERMISSION_DENIED);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_PERMISSION_DENIED, rpromise);
promise_value = eina_value_new(eina_value_type_get(value));
eina_value_copy(value, promise_value);
eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
return rpromise;
}
static Eo *
@ -181,24 +182,26 @@ _eldbus_model_arguments_efl_model_child_del(Eo *obj EINA_UNUSED,
{
}
static void
static Eina_Promise*
_eldbus_model_arguments_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Arguments_Data *pd EINA_UNUSED,
unsigned start EINA_UNUSED,
unsigned count EINA_UNUSED,
Eina_Promise_Owner *promise)
unsigned count EINA_UNUSED)
{
Eina_Promise_Owner *promise = eina_promise_add();
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
return eina_promise_owner_promise_get(promise);
}
static void
static Eina_Promise*
_eldbus_model_arguments_efl_model_children_count_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Arguments_Data *pd EINA_UNUSED,
Eina_Promise_Owner *promise)
Eldbus_Model_Arguments_Data *pd EINA_UNUSED)
{
Eina_Promise_Owner *promise = eina_promise_add();
unsigned *count = malloc(sizeof(unsigned));
*count = 0;
eina_promise_owner_value_set(promise, count, free);
return eina_promise_owner_promise_get(promise);
}
static const char *

44
src/lib/eldbus/eldbus_model_connection.c
View File

@ -87,36 +87,38 @@ _eldbus_model_connection_efl_model_property_set(Eo *obj EINA_UNUSED,
Eina_Value const* value EINA_UNUSED,
Eina_Promise_Owner *promise)
{
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, );
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_READ_ONLY);
}
static void
static Eina_Promise*
_eldbus_model_connection_efl_model_property_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Connection_Data *pd,
const char *property,
Eina_Promise_Owner *promise)
const char *property)
{
EINA_SAFETY_ON_NULL_RETURN(promise);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
DBG("(%p): property=%s", obj, property);
if (!pd->connection)
_eldbus_model_connection_connect(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
if (pd->unique_name == NULL)
{
const char *unique_name;
unique_name = eldbus_connection_unique_name_get(pd->connection);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
pd->unique_name = strdup(unique_name);
}
Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
eina_value_set(v, pd->unique_name);
eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
return rpromise;
}
static Eo *
@ -132,16 +134,20 @@ _eldbus_model_connection_efl_model_child_del(Eo *obj EINA_UNUSED,
{
}
static void
static Eina_Promise*
_eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Connection_Data *pd,
unsigned start,
unsigned count,
Eina_Promise_Owner *promise)
unsigned int start,
unsigned int count)
{
Eina_Promise_Owner *promise;
Eina_Promise *rpromise;
_Eldbus_Children_Slice_Promise* data;
Eldbus_Pending *pending;
promise = eina_promise_add();
rpromise = eina_promise_owner_promise_get(promise);
if (!pd->connection)
_eldbus_model_connection_connect(pd);
@ -149,11 +155,11 @@ _eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
{
Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
return;
return eina_promise_owner_promise_get(promise);
}
data = calloc(1, sizeof(struct _Eldbus_Children_Slice_Promise));
EINA_SAFETY_ON_NULL_RETURN(data);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, rpromise);
data->promise = promise;
data->start = start;
data->count = count;
@ -165,14 +171,17 @@ _eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
pending = eldbus_names_list(pd->connection, &_eldbus_model_connection_names_list_cb, pd);
pd->pending_list = eina_list_append(pd->pending_list, pending);
}
return rpromise;
}
static void
static Eina_Promise*
_eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Connection_Data *pd,
Eina_Promise_Owner *promise)
Eldbus_Model_Connection_Data *pd)
{
Eina_Promise_Owner *promise;
Eldbus_Pending *pending;
promise = eina_promise_add();
if (!pd->connection)
_eldbus_model_connection_connect(pd);
@ -181,7 +190,7 @@ _eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
unsigned int *c = calloc(sizeof(unsigned int), 1);
*c = eina_list_count(pd->children_list);
eina_promise_owner_value_set(promise, c, free);
return;
return eina_promise_owner_promise_get(promise);
}
pd->count_promises = eina_list_prepend(pd->count_promises, promise);
@ -190,6 +199,7 @@ _eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
pending = eldbus_names_list(pd->connection, &_eldbus_model_connection_names_list_cb, pd);
pd->pending_list = eina_list_append(pd->pending_list, pending);
}
return eina_promise_owner_promise_get(promise);
}
static const char *

38
src/lib/eldbus/eldbus_model_object.c
View File

@ -120,38 +120,39 @@ _eldbus_model_object_efl_model_property_set(Eo *obj EINA_UNUSED,
const Eina_Value *value EINA_UNUSED,
Eina_Promise_Owner *promise)
{
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, );
eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_READ_ONLY);
}
static void
static Eina_Promise*
_eldbus_model_object_efl_model_property_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Object_Data *pd,
const char *property,
Eina_Promise_Owner *promise)
const char *property)
{
EINA_SAFETY_ON_NULL_RETURN(promise);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
DBG("(%p): property=%s", obj, property);
if (!pd->connection)
_eldbus_model_object_connect(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
if (pd->unique_name == NULL)
{
const char *unique_name;
unique_name = eldbus_connection_unique_name_get(pd->connection);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
pd->unique_name = strdup(unique_name);
}
Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
eina_value_set(v, pd->unique_name);
eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
return eina_promise_owner_promise_get(promise);
}
static Eo *
@ -167,14 +168,15 @@ _eldbus_model_object_efl_model_child_del(Eo *obj EINA_UNUSED,
{
}
static void
static Eina_Promise*
_eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Object_Data *pd,
unsigned start,
unsigned count,
Eina_Promise_Owner *promise)
unsigned count)
{
_Eldbus_Children_Slice_Promise* p;
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
if (!pd->connection)
_eldbus_model_object_connect(pd);
@ -183,11 +185,11 @@ _eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
{
Eina_Accessor* ac = efl_model_list_slice(pd->children_list, start, count);
eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
return;
return eina_promise_owner_promise_get(promise);
}
p = calloc(1, sizeof(struct _Eldbus_Children_Slice_Promise));
EINA_SAFETY_ON_NULL_RETURN(p);
EINA_SAFETY_ON_NULL_RETURN_VAL(p, rpromise);
p->promise = promise;
p->start = start;
p->count = count;
@ -195,13 +197,14 @@ _eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
pd->children_promises = eina_list_prepend(pd->children_promises, p);
if (pd->pending_list == NULL)
_eldbus_model_object_introspect(pd, pd->bus, pd->path);
return rpromise;
}
static void
static Eina_Promise*
_eldbus_model_object_efl_model_children_count_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Object_Data *pd,
Eina_Promise_Owner *promise)
Eldbus_Model_Object_Data *pd)
{
Eina_Promise_Owner *promise = eina_promise_add();
if (!pd->connection)
_eldbus_model_object_connect(pd);
@ -210,12 +213,13 @@ _eldbus_model_object_efl_model_children_count_get(Eo *obj EINA_UNUSED,
unsigned int *c = calloc(sizeof(unsigned int), 1);
*c = eina_list_count(pd->children_list);
eina_promise_owner_value_set(promise, c, free);
return;
return eina_promise_owner_promise_get(promise);
}
pd->count_promises = eina_list_prepend(pd->count_promises, promise);
if (pd->pending_list == NULL)
_eldbus_model_object_introspect(pd, pd->bus, pd->path);
return eina_promise_owner_promise_get(promise);
}
static const char *

4
src/lib/eldbus/eldbus_model_private.h
View File

@ -26,13 +26,13 @@ struct _Eldbus_Property_Promise
/* logging support */
extern int eldbus_model_log_dom;
#define ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(exp, promise, err) \
#define ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(exp, promise, err, v) \
do \
{ \
if (EINA_UNLIKELY(!(exp))) \
{ \
eina_promise_owner_error_set(promise, err); \
return; \
return v; \
} \
} \
while(0)

55
src/lib/eldbus/eldbus_model_proxy.c
View File

@ -116,23 +116,23 @@ _eldbus_model_proxy_efl_model_property_set(Eo *obj EINA_UNUSED,
Eldbus_Pending *pending;
Eina_Bool ret;
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
DBG("(%p): property=%s", obj, property);
ret = _eldbus_model_proxy_load(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, );
ret = _eldbus_model_proxy_has_property(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, );
ret = _eldbus_model_proxy_is_property_writeable(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, );
signature = _eldbus_model_proxy_property_type_get(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(signature, promise, EFL_MODEL_ERROR_UNKNOWN);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(signature, promise, EFL_MODEL_ERROR_UNKNOWN, );
data = _eldbus_model_proxy_property_set_data_new(pd, property, value, promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(data, promise, EFL_MODEL_ERROR_UNKNOWN);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(data, promise, EFL_MODEL_ERROR_UNKNOWN, );
if (!pd->is_loaded)
{
@ -156,29 +156,29 @@ _eldbus_model_proxy_efl_model_property_set(Eo *obj EINA_UNUSED,
pd->pending_list = eina_list_append(pd->pending_list, pending);
}
static void
static Eina_Promise*
_eldbus_model_proxy_efl_model_property_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Proxy_Data *pd,
const char *property,
Eina_Promise_Owner *promise)
const char *property)
{
Eina_Bool ret;
Eina_Value *promise_value;
EINA_SAFETY_ON_NULL_RETURN(promise);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
ret = _eldbus_model_proxy_load(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
ret = _eldbus_model_proxy_has_property(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
if (!pd->is_loaded)
{
Eldbus_Pending *pending;
_Eldbus_Property_Promise *p = calloc(1, sizeof(_Eldbus_Property_Promise));
EINA_SAFETY_ON_NULL_RETURN(p);
EINA_SAFETY_ON_NULL_RETURN_VAL(p, rpromise);
p->promise = promise;
p->property = strdup(property);
@ -189,18 +189,19 @@ _eldbus_model_proxy_efl_model_property_get(Eo *obj EINA_UNUSED,
pending = eldbus_proxy_property_get_all(pd->proxy, _eldbus_model_proxy_property_get_all_cb, pd);
pd->pending_list = eina_list_append(pd->pending_list, pending);
}
return;
return rpromise;
}
Eina_Value* value = eina_hash_find(pd->properties_hash, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
ret = _eldbus_model_proxy_is_property_writeable(pd, property);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, rpromise);
promise_value = eina_value_new(eina_value_type_get(value));
eina_value_copy(value, promise_value);
eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
return rpromise;
}
static Eo *
@ -217,15 +218,16 @@ _eldbus_model_proxy_efl_model_child_del(Eo *obj EINA_UNUSED,
{
}
static void
static Eina_Promise*
_eldbus_model_proxy_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Proxy_Data *pd,
unsigned start,
unsigned count,
Eina_Promise_Owner *promise)
unsigned count)
{
Eina_Bool ret = _eldbus_model_proxy_load(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
if (!pd->is_listed)
{
@ -236,15 +238,17 @@ _eldbus_model_proxy_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
return rpromise;
}
static void
static Eina_Promise*
_eldbus_model_proxy_efl_model_children_count_get(Eo *obj EINA_UNUSED,
Eldbus_Model_Proxy_Data *pd,
Eina_Promise_Owner *promise)
Eldbus_Model_Proxy_Data *pd)
{
Eina_Bool ret = _eldbus_model_proxy_load(pd);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED);
Eina_Promise_Owner *promise = eina_promise_add();
Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
if (!pd->is_listed)
{
@ -256,6 +260,7 @@ _eldbus_model_proxy_efl_model_children_count_get(Eo *obj EINA_UNUSED,
unsigned int *c = calloc(sizeof(unsigned int), 1);
*c = eina_list_count(pd->children_list);
eina_promise_owner_value_set(promise, c, free);
return eina_promise_owner_promise_get(promise);
}
static void

34
src/lib/elementary/elc_fileselector.c
View File

@ -836,12 +836,12 @@ _process_children_cb(void *data, void *values)
it_data->model = eo_ref(child);
it_data->user_data = lreq;
efl_model_property_get(child, "path", &promises[0]);
efl_model_property_get(child, "filename", &promises[1]);
efl_model_property_get(child, "is_dir", &promises[2]);
efl_model_property_get(child, "size", &promises[3]);
efl_model_property_get(child, "mtime", &promises[4]);
efl_model_property_get(child, "mime_type", &promises[5]);
promises[0] = efl_model_property_get(child, "path");
promises[1] = efl_model_property_get(child, "filename");
promises[2] = efl_model_property_get(child, "is_dir");
promises[3] = efl_model_property_get(child, "size");
promises[4] = efl_model_property_get(child, "mtime");
promises[5] = efl_model_property_get(child, "mime_type");
promise_all = eina_promise_all(eina_carray_iterator_new((void**)promises));
++(lreq->item_total);
@ -928,10 +928,10 @@ _populate(Evas_Object *obj,
Eina_Promise *promises[4] = {NULL,};
Eina_Promise *promise_all = NULL;
efl_model_property_get(model, "path", &promises[0]);
efl_model_children_slice_get(model, 0, 0, &promises[1]);
promises[0] = efl_model_property_get(model, "path");
promises[1] = efl_model_children_slice_get(model, 0, 0);
if (selected)
efl_model_property_get(selected, "path", &promises[2]);
promises[2] = efl_model_property_get(selected, "path");
promise_all = eina_promise_all(eina_carray_iterator_new((void**)&promises[0]));
eina_promise_then(promise_all, _process_children_cb, _process_children_error_cb, lreq);
@ -1415,7 +1415,7 @@ _on_text_activated_set_path_then(void *data, void *value EINA_UNUSED)
if (!sd->model) return ;
efl_model_property_get(sd->model, "is_dir", &promise);
promise = efl_model_property_get(sd->model, "is_dir");
eina_promise_then
(promise, _text_activated_is_dir_then, _text_activated_is_dir_then_error, data);
}
@ -1736,12 +1736,12 @@ _resource_created(void *data, const Eo_Event *event)
it_data->model = eo_ref(child);
it_data->user_data = eo_ref(fs);
efl_model_property_get(child, "path", &promises[0]);
efl_model_property_get(child, "filename", &promises[1]);
efl_model_property_get(child, "is_dir", &promises[2]);
efl_model_property_get(child, "size", &promises[3]);
efl_model_property_get(child, "mtime", &promises[4]);
efl_model_property_get(child, "mime_type", &promises[5]);
promises[0] = efl_model_property_get(child, "path");
promises[1] = efl_model_property_get(child, "filename");
promises[2] = efl_model_property_get(child, "is_dir");
promises[3] = efl_model_property_get(child, "size");
promises[4] = efl_model_property_get(child, "mtime");
promises[5] = efl_model_property_get(child, "mime_type");
promise_all = eina_promise_all(eina_carray_iterator_new((void**)promises));
@ -2502,7 +2502,7 @@ _elm_fileselector_elm_interface_fileselector_selected_model_set(Eo *obj, Elm_Fil
eina_promise_owner_error_set(promise_owner, ELM_FILESELECTOR_ERROR_INVALID_MODEL);
return;
}
efl_model_property_get(model, "is_dir", &promise);
promise = efl_model_property_get(model, "is_dir");
eo_key_obj_set(obj, _selected_model_set_model_key, model);
if (promise_owner)

4
src/lib/elementary/elc_fileselector_button.c
View File

@ -97,7 +97,7 @@ _selection_done(void *data, const Eo_Event *event)
if (sd->fsd.model)
eo_unref(sd->fsd.model);
sd->fsd.model = eo_ref(model);
efl_model_property_get(model, "path", &promise);
promise = efl_model_property_get(model, "path");
eina_promise_then(promise, _replace_path_then, _replace_path_then_error, sd);
}
@ -357,7 +357,7 @@ _elm_fileselector_button_elm_interface_fileselector_model_set(Eo *obj EINA_UNUSE
{
Eina_Promise *promise = NULL;
sd->fsd.model = eo_ref(model);
efl_model_property_get(model, "path", &promise);
promise = efl_model_property_get(model, "path");
eina_promise_then(promise, _replace_path_then, _replace_path_then_error, sd);
}
else

4
src/lib/elementary/elc_fileselector_entry.c
View File

@ -92,7 +92,7 @@ _FILE_CHOSEN_fwd(void *data, const Eo_Event *event)
if (!model) return EINA_TRUE;
efl_model_property_get(model, "path", &promise);
promise = efl_model_property_get(model, "path");
eina_promise_then(promise, _file_chosen_path_then, NULL, data);
// EVENTS: should not call legacy
@ -509,7 +509,7 @@ _elm_fileselector_entry_elm_interface_fileselector_model_set(Eo *obj EINA_UNUSED
Eina_Promise *p = NULL;
elm_interface_fileselector_model_set(sd->button, model);
efl_model_property_get(model, "path", &p);
p = efl_model_property_get(model, "path");
eina_promise_then(p, _fs_entry_model_path_get_then, NULL, sd);
}

6
src/lib/elementary/elm_view_form.c
View File

@ -114,7 +114,7 @@ _efl_model_properties_change_cb(void *data, const Eo_Event *event)
p = calloc(1, sizeof(Elm_View_Form_Promise));
p->property_name = eina_stringshare_add(prop);
p->priv = priv;
efl_model_property_get(priv->model_obj, prop, &promise);
promise = efl_model_property_get(priv->model_obj, prop);
eina_promise_then(promise, &_efl_model_promise_then_cb,
&_efl_model_promise_error_cb, p);
}
@ -134,7 +134,7 @@ _update_model_properties(Elm_View_Form_Data *priv)
EINA_LIST_FOREACH(priv->widgets, l, w)
{
efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
promise = efl_model_property_get(priv->model_obj, w->widget_propname);
eina_promise_then(promise, &_efl_promise_then_widget, &_efl_promise_error_widget, w);
}
}
@ -243,7 +243,7 @@ _elm_view_widget_add(Elm_View_Form_Data *priv, const char *propname, Evas_Object
if (priv->model_obj != NULL)
{
efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
promise = efl_model_property_get(priv->model_obj, w->widget_propname);
eina_promise_then(promise, &_efl_promise_then_widget,
&_efl_promise_error_widget, priv);
}

4
src/lib/elementary/elm_view_list.c
View File

@ -152,7 +152,7 @@ _item_get_value(View_List_ItemData *idata, const char *part)
vitem->part = eina_stringshare_add(part);
vitem->item = idata->item;
idata->values = eina_list_append(idata->values, vitem);
efl_model_property_get(idata->model, prop, &promise);
promise = efl_model_property_get(idata->model, prop);
eina_promise_then(promise, &_property_get_cb,
&_property_get_error_cb, vitem);
}
@ -339,7 +339,7 @@ _efl_model_load_children(View_List_ItemData *pdata)
{
Eina_Promise *promise;
efl_model_children_slice_get(pdata->model, 0, 0, &promise);
promise = efl_model_children_slice_get(pdata->model, 0, 0);
eina_promise_then(promise, &_efl_model_load_children_then, NULL, pdata);
}

10
src/tests/eio/eio_model_test_file.c
View File

@ -121,23 +121,23 @@ START_TEST(eio_model_test_test_file)
Eina_Promise *promise;
efl_model_property_get(filemodel, "filename", &promise);
promise = efl_model_property_get(filemodel, "filename");
eina_promise_then(promise, &promise_then_value, &error_promise_then, NULL);
ecore_main_loop_begin();
efl_model_property_get(filemodel, "size", &promise);
promise = efl_model_property_get(filemodel, "size");
eina_promise_then(promise, &promise_then_value, &error_promise_then, NULL);
ecore_main_loop_begin();
efl_model_property_get(filemodel, "mtime", &promise);
promise = efl_model_property_get(filemodel, "mtime");
eina_promise_then(promise, &promise_then_value, &error_promise_then, NULL);
ecore_main_loop_begin();
efl_model_children_slice_get(filemodel, 0, 0, &promise);
promise = efl_model_children_slice_get(filemodel, 0, 0);
eina_promise_then(promise, &promise_then_accessor, &error_promise_then, NULL);
ecore_main_loop_begin();
efl_model_children_count_get(filemodel, &promise);
promise = efl_model_children_count_get(filemodel);
eina_promise_then(promise, &promise_then_count, &error_promise_then, NULL);
ecore_main_loop_begin();

6
src/tests/eio/eio_model_test_monitor_add.c
View File

@ -30,7 +30,7 @@ _children_removed_cb(void *data EINA_UNUSED, const Eo_Event* event)
Efl_Model_Children_Event* evt = event->info;
Eina_Promise* promise;
efl_model_property_get(evt->child, "path", &promise);
promise = efl_model_property_get(evt->child, "path");
Eina_Value const* value = eina_promise_value_get(promise);
char* filename = eina_value_to_string(value);
@ -49,7 +49,7 @@ _children_added_cb(void *data EINA_UNUSED, const Eo_Event* event)
Efl_Model_Children_Event* evt = event->info;
Eina_Promise* promise;
efl_model_property_get(evt->child, "path", &promise);
promise = efl_model_property_get(evt->child, "path");
Eina_Value const* value = eina_promise_value_get(promise);
char* filename = eina_value_to_string(value);
@ -104,7 +104,7 @@ START_TEST(eio_model_test_test_monitor_add)
eo_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_REMOVED, &_children_removed_cb, NULL);
Eina_Promise* promise;
efl_model_children_slice_get(filemodel, 0, 0, &promise);
promise = efl_model_children_slice_get(filemodel, 0, 0);
eina_promise_then(promise, &_create_file, &_create_file_error, NULL);

26
src/tests/eldbus/eldbus_test_eldbus_model.c
View File

@ -109,7 +109,7 @@ efl_model_nth_child_get(Efl_Model *efl_model, unsigned int n)
{
Eina_Accessor *accessor;
Eina_Promise *promise;
efl_model_children_slice_get(efl_model, n, 1, &promise);
promise = efl_model_children_slice_get(efl_model, n, 1);
eina_promise_ref(promise);
ck_assert_ptr_ne(NULL, promise);
@ -150,7 +150,7 @@ void
check_property(Eo *object, const char *property_name, const char *expected_value)
{
Eina_Promise *promise;
efl_model_property_get(object, property_name, &promise);
promise = efl_model_property_get(object, property_name);
ck_assert_ptr_ne(NULL, promise);
Eina_Value *value = efl_model_promise_then(promise);
char *actual_value;
@ -186,7 +186,7 @@ check_efl_model_children_count_eq(Efl_Model *efl_model, unsigned int expected_ch
{
unsigned int actual_children_count;
Eina_Promise *promise;
efl_model_children_count_get(efl_model, &promise);
promise = efl_model_children_count_get(efl_model);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_eq(expected_children_count, actual_children_count);
}
@ -196,7 +196,7 @@ check_efl_model_children_count_ge(Efl_Model *efl_model, unsigned int minimum_chi
{
unsigned int actual_children_count;
Eina_Promise *promise;
efl_model_children_count_get(efl_model, &promise);
promise = efl_model_children_count_get(efl_model);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_ge(actual_children_count, minimum_children_count);
}
@ -207,12 +207,12 @@ check_efl_model_children_slice_get(Efl_Model *efl_model)
unsigned count;
Eina_Promise *promise;
Eina_Accessor *accessor;
efl_model_children_count_get(efl_model, &promise);
promise = efl_model_children_count_get(efl_model);
count = efl_model_promise_then_u(promise);
ck_assert_msg(count, "There must be at least 1 child to test");
// Test slice all
efl_model_children_slice_get(efl_model, 0, 0, &promise);
promise = efl_model_children_slice_get(efl_model, 0, 0);
eina_promise_ref(promise);
accessor = efl_model_promise_then(promise);
ck_assert_ptr_ne(NULL, accessor);
@ -235,7 +235,7 @@ check_efl_model_children_slice_get(Efl_Model *efl_model)
// Test slice first child
Eo *child = NULL;
efl_model_children_slice_get(efl_model, 1, 1, &promise);
promise = efl_model_children_slice_get(efl_model, 1, 1);
eina_promise_ref(promise);
accessor = efl_model_promise_then(promise);
ck_assert_ptr_ne(NULL, accessor);
@ -248,7 +248,7 @@ check_efl_model_children_slice_get(Efl_Model *efl_model)
eina_promise_unref(promise);
// Test slice last child
efl_model_children_slice_get(efl_model, count, 1, &promise);
promise = efl_model_children_slice_get(efl_model, count, 1);
eina_promise_ref(promise);
accessor = efl_model_promise_then(promise);
ck_assert_ptr_ne(NULL, accessor);
@ -261,7 +261,7 @@ check_efl_model_children_slice_get(Efl_Model *efl_model)
eina_promise_unref(promise);
// Test slice nonexistent element
efl_model_children_slice_get(efl_model, count + 1, 1, &promise);
promise = efl_model_children_slice_get(efl_model, count + 1, 1);
eina_promise_ref(promise);
ck_assert_ptr_ne(NULL, promise);
accessor = efl_model_promise_then(promise);
@ -300,7 +300,7 @@ START_TEST(proxy)
Eina_Accessor *accessor = NULL;
Eina_Promise *promise = NULL;
efl_model_children_slice_get(root, 0, 0, &promise);
promise = efl_model_children_slice_get(root, 0, 0);
eina_promise_ref(promise);
ck_assert_ptr_ne(NULL, promise);
@ -335,7 +335,7 @@ eldbus_model_proxy_from_object_get(Eldbus_Model_Object *object, const char *inte
{
Eina_Accessor *accessor;
Eina_Promise *promise = NULL;
efl_model_children_slice_get(object, 0, 0, &promise);
promise = efl_model_children_slice_get(object, 0, 0);
ck_assert_ptr_ne(NULL, promise);
eina_promise_ref(promise);
accessor = efl_model_promise_then(promise);
@ -363,7 +363,7 @@ _eldbus_model_arguments_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *me
{
Eina_Accessor *accessor;
Eina_Promise *promise = NULL;
efl_model_children_slice_get(proxy, 0, 0, &promise);
promise = efl_model_children_slice_get(proxy, 0, 0);
ck_assert_ptr_ne(NULL, promise);
eina_promise_ref(promise);
accessor = efl_model_promise_then(promise);
@ -406,7 +406,7 @@ check_efl_model_property_int_eq(Efl_Model *efl_model, const char *property, int
{
Eina_Value property_value;
Eina_Promise *promise;
efl_model_property_get(efl_model, property, &promise);
promise = efl_model_property_get(efl_model, property);
ck_assert_ptr_ne(NULL, promise);
eina_promise_then(promise, &_promise_then_cp, &_error_then_cb, &property_value);

8
src/tests/eldbus/eldbus_test_eldbus_model_connection.c
View File

@ -44,12 +44,12 @@ END_TEST
START_TEST(property_get)
{
Eina_Promise *promise;
efl_model_property_get(connection, UNIQUE_NAME_PROPERTY, &promise);
promise = efl_model_property_get(connection, UNIQUE_NAME_PROPERTY);
efl_model_promise_then(promise);
// Nonexistent property must raise ERROR
promise = NULL;
efl_model_property_get(connection, "nonexistent", &promise);
promise = efl_model_property_get(connection, "nonexistent");
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_FOUND);
}
END_TEST
@ -105,7 +105,7 @@ START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Eina_Promise *promise;
efl_model_children_count_get(connection, &promise);
promise = efl_model_children_count_get(connection);
ck_assert_ptr_ne(NULL, promise);
expected_children_count = efl_model_promise_then_u(promise);
@ -113,7 +113,7 @@ START_TEST(child_del)
efl_model_child_del(connection, child);
unsigned int actual_children_count = 0;
efl_model_children_count_get(connection, &promise);
promise = efl_model_children_count_get(connection);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_le(expected_children_count, actual_children_count);

8
src/tests/eldbus/eldbus_test_eldbus_model_method.c
View File

@ -65,14 +65,14 @@ START_TEST(property_get)
{
// Input only property returns error
Eina_Promise *promise;
efl_model_property_get(method, ARGUMENT_A, &promise);
promise = efl_model_property_get(method, ARGUMENT_A);
check_efl_model_promise_error(promise, NULL);
efl_model_property_get(method, ARGUMENT_RESULT, &promise);
promise = efl_model_property_get(method, ARGUMENT_RESULT);
efl_model_promise_then(promise);
// Nonexistent property returns error
efl_model_property_get(method, "nonexistent", &promise);
promise = efl_model_property_get(method, "nonexistent");
check_efl_model_promise_error(promise, NULL);
}
END_TEST
@ -102,7 +102,7 @@ END_TEST
START_TEST(children_slice_get)
{
Eina_Promise *promise;
efl_model_children_slice_get(method, 1, 1, &promise);
promise = efl_model_children_slice_get(method, 1, 1);
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_SUPPORTED);
}
END_TEST

8
src/tests/eldbus/eldbus_test_eldbus_model_object.c
View File

@ -44,12 +44,12 @@ END_TEST
START_TEST(property_get)
{
Eina_Promise *promise;
efl_model_property_get(object, UNIQUE_NAME_PROPERTY, &promise);
promise = efl_model_property_get(object, UNIQUE_NAME_PROPERTY);
efl_model_promise_then(promise);
// Nonexistent property must raise ERROR
promise = NULL;
efl_model_property_get(object, "nonexistent", &promise);
promise = efl_model_property_get(object, "nonexistent");
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_FOUND);
}
END_TEST
@ -105,7 +105,7 @@ START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Eina_Promise *promise;
efl_model_children_count_get(object, &promise);
promise = efl_model_children_count_get(object);
ck_assert_ptr_ne(NULL, promise);
expected_children_count = efl_model_promise_then_u(promise);
ck_assert_msg(expected_children_count, "There must be at least 1 child to test");
@ -115,7 +115,7 @@ START_TEST(child_del)
promise = NULL;
unsigned int actual_children_count = 0;
efl_model_children_count_get(object, &promise);
promise = efl_model_children_count_get(object);
ck_assert_ptr_ne(NULL, promise);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_le(expected_children_count, actual_children_count);

6
src/tests/eldbus/eldbus_test_eldbus_model_proxy.c
View File

@ -45,7 +45,7 @@ START_TEST(property_get)
{
// Nonexistent property must return ERROR
Eina_Promise *promise;
efl_model_property_get(dbus_proxy, "nonexistent", &promise);
promise = efl_model_property_get(dbus_proxy, "nonexistent");
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_FOUND);
}
END_TEST
@ -95,7 +95,7 @@ START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Eina_Promise *promise;
efl_model_children_count_get(dbus_proxy, &promise);
promise = efl_model_children_count_get(dbus_proxy);
ck_assert_ptr_ne(NULL, promise);
expected_children_count = efl_model_promise_then_u(promise);
@ -103,7 +103,7 @@ START_TEST(child_del)
efl_model_child_del(dbus_proxy, child);
unsigned int actual_children_count = 0;
efl_model_children_count_get(dbus_proxy, &promise);
promise = efl_model_children_count_get(dbus_proxy);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_le(expected_children_count, actual_children_count);

6
src/tests/eldbus/eldbus_test_eldbus_model_signal.c
View File

@ -63,11 +63,11 @@ START_TEST(property_get)
{
// Signal properties always have output direction
Eina_Promise *promise;
efl_model_property_get(pong_signal, ARGUMENT_A, &promise);
promise = efl_model_property_get(pong_signal, ARGUMENT_A);
efl_model_promise_then(promise);
// Nonexistent property must return ERROR
efl_model_property_get(pong_signal, "nonexistent", &promise);
promise = efl_model_property_get(pong_signal, "nonexistent");
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_FOUND);
}
END_TEST
@ -97,7 +97,7 @@ END_TEST
START_TEST(children_slice_get)
{
Eina_Promise *promise;
efl_model_children_slice_get(pong_signal, 1, 1, &promise);
promise = efl_model_children_slice_get(pong_signal, 1, 1);
check_efl_model_promise_error(promise, &EFL_MODEL_ERROR_NOT_SUPPORTED);
}
END_TEST

7
src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c
View File

@ -69,7 +69,8 @@ START_TEST(property_get)
// Write-only property returns error
Eina_Promise *promise;
efl_model_property_get(fake_server_proxy, FAKE_SERVER_WRITEONLY_PROPERTY, &promise);
promise = efl_model_property_get(fake_server_proxy, FAKE_SERVER_WRITEONLY_PROPERTY);
(void)promise;
//ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
_teardown();
@ -160,7 +161,7 @@ START_TEST(child_del)
// Tests that it is not possible to delete children
Eina_Promise *promise;
unsigned int expected_children_count = 0;
efl_model_children_count_get(fake_server_proxy, &promise);
promise = efl_model_children_count_get(fake_server_proxy);
expected_children_count = efl_model_promise_then_u(promise);
ck_assert_msg(expected_children_count, "There must be at least 1 child to test");
@ -169,7 +170,7 @@ START_TEST(child_del)
efl_model_child_del(fake_server_proxy, child);
unsigned int actual_children_count = 0;
efl_model_children_count_get(fake_server_proxy, &promise);
promise = efl_model_children_count_get(fake_server_proxy);
actual_children_count = efl_model_promise_then_u(promise);
ck_assert_int_le(expected_children_count, actual_children_count);