static void
process(Eo *child, unsigned int index)
{
- Eina_Array *properties = efl_model_properties_get(child);
+ Eina_Iterator *properties = efl_model_properties_get(child);
const char *property;
- Eina_Array_Iterator it;
Eina_Strbuf *buf;
- unsigned int i;
+ Eina_Bool noproperties = EINA_TRUE;
buf = eina_strbuf_new();
const char *name = eldbus_model_proxy_name_get(child);
- EINA_ARRAY_ITER_NEXT(properties, i, property, it)
+ EINA_ITERATOR_FOREACH(properties, property)
{
Eina_Value *v = efl_model_property_get(child, property);
char *str;
free(str);
eina_value_free(v);
+
+ noproperties = EINA_FALSE;
}
+ eina_iterator_free(properties);
- if (eina_array_count(properties) <= 0)
+ if (noproperties)
eina_strbuf_append_printf(buf, " %2d: %s (no properties yet)\n", index, name);
else
eina_strbuf_prepend_printf(buf, " -> %s\n Properties:\n", name);
printf("%s", eina_strbuf_string_get(buf));
- eina_array_free(properties);
eina_strbuf_free(buf);
efl_ref(child);
return efl_model_property_get(pd->source, property);
}
-static Eina_Array *
+static Eina_Iterator *
_efl_model_composite_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Composite_Data *pd)
{
return efl_model_properties_get(pd->source);
return obj;
}
-static Eina_Array *
+static Eina_Iterator *
_efl_model_composite_boolean_children_efl_model_properties_get(const Eo *obj,
Efl_Model_Composite_Boolean_Children_Data *pd)
{
- Eina_Iterator *it;
- Eina_Stringshare *s;
- Eina_Array *r;
+ Eina_Iterator *its;
+ Eina_Iterator *itr;
- r = efl_model_properties_get(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS));
- if (!r) r = eina_array_new(1);
+ its = efl_model_properties_get(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS));
+ itr = eina_hash_iterator_key_new(pd->parent->values);
- it = eina_hash_iterator_key_new(pd->parent->values);
- EINA_ITERATOR_FOREACH(it, s)
- eina_array_push(r, s);
- eina_array_push(r, "child.index");
+ if (!its) return itr;
+ if (!itr) return its;
- return r;
+ return eina_multi_iterator_new(its, itr);
}
static Eina_Value *
return EINA_FALSE;
}
-static Eina_Array *
+static Eina_Iterator *
_efl_model_container_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd)
{
- Eina_Iterator *it;
- Eina_Array *r;
- Eina_Stringshare *s;
-
- r = eina_array_new(1);
- it = eina_hash_iterator_key_new(sd->properties);
- EINA_ITERATOR_FOREACH(it, s)
- eina_array_push(r, eina_stringshare_ref(s));
- eina_iterator_free(it);
-
- return r;
+ return eina_hash_iterator_key_new(sd->properties);
}
static Eina_Future *
sd->index = 0;
}
-static Eina_Array *
+static Eina_Iterator *
_efl_model_container_item_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Container_Item_Data *sd)
{
// FIXME: Not to sure here, shouldn't we extend a child of the parent actually ?
struct _Efl_Model_Item_Data
{
Eina_Hash *properties;
- Eina_Array *defined_properties;
Eina_List *childrens;
};
return NULL;
sd->properties = eina_hash_stringshared_new(_item_value_free_cb);
- sd->defined_properties = eina_array_new(8);
return obj;
}
eina_hash_foreach(sd->properties, _stringshared_keys_free, NULL);
eina_hash_free(sd->properties);
- eina_array_free(sd->defined_properties);
-
efl_destructor(efl_super(obj, MY_CLASS));
}
-static Eina_Array *
+static Eina_Iterator *
_efl_model_item_efl_model_properties_get(const Eo *obj EINA_UNUSED, Efl_Model_Item_Data *pd)
{
- return pd->defined_properties;
+ return eina_hash_iterator_key_new(pd->properties);
}
static Eina_Future *
]]
}
values {
- properties: array<string>; [[Array of current properties]]
+ properties: iterator<string> @owned; [[Array of current properties]]
}
}
@property property {
/**
* Interfaces impl.
*/
-static Eina_Array *
+static Eina_Iterator *
_eio_model_efl_model_properties_get(const Eo *obj EINA_UNUSED,
Eio_Model_Data *pd EINA_UNUSED)
{
- Eina_Array *r;
- unsigned int i;
-
- r = eina_array_new(4);
- for (i = 0; i < EINA_C_ARRAY_LENGTH(properties); ++i)
- eina_array_push(r, properties[i].name);
-
- return r;
+ return EINA_C_ARRAY_ITERATOR_NEW(properties);
}
static Eina_Value *
return eina_value_error_new(EFL_MODEL_ERROR_NOT_FOUND);
}
-static Eina_Array *
+static Eina_Iterator *
_eldbus_model_efl_model_properties_get(const Eo *obj EINA_UNUSED,
Eldbus_Model_Data *pd EINA_UNUSED)
{
- Eina_Array *r;
+ char *unique[] = { UNIQUE_NAME_PROPERTY };
- r = eina_array_new(1);
- eina_array_push(r, eina_stringshare_add(UNIQUE_NAME_PROPERTY));
-
- return r;
+ return EINA_C_ARRAY_ITERATOR_NEW(unique);
}
static Efl_Object *
#define MY_CLASS ELDBUS_MODEL_ARGUMENTS_CLASS
#define MY_CLASS_NAME "Eldbus_Model_Arguments"
-#define ARGUMENT_FORMAT "arg%u"
-
static void _eldbus_model_arguments_properties_load(Eldbus_Model_Arguments_Data *);
static void _eldbus_model_arguments_unload(Eldbus_Model_Arguments_Data *);
static Eina_Bool _eldbus_model_arguments_is_input_argument(Eldbus_Model_Arguments_Data *, const char *);
_eldbus_model_arguments_efl_object_constructor(Eo *obj, Eldbus_Model_Arguments_Data *pd)
{
pd->obj = obj;
- pd->properties_array = NULL;
- pd->properties_hash = eina_hash_string_superfast_new(EINA_FREE_CB(_eldbus_model_arguments_hash_free));
+ // We do keep strings here as some of our API are looking for arg%u as a key instead of just indexes.
+ pd->properties = eina_hash_string_superfast_new(EINA_FREE_CB(_eldbus_model_arguments_hash_free));
pd->pending_list = NULL;
pd->proxy = NULL;
pd->arguments = NULL;
{
_eldbus_model_arguments_unload(pd);
- eina_hash_free(pd->properties_hash);
+ eina_hash_free(pd->properties);
eina_stringshare_del(pd->name);
eldbus_proxy_unref(pd->proxy);
efl_destructor(efl_super(obj, MY_CLASS));
}
-static Eina_Array *
+static Eina_Iterator *
_eldbus_model_arguments_efl_model_properties_get(const Eo *obj EINA_UNUSED,
Eldbus_Model_Arguments_Data *pd)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(pd, NULL);
_eldbus_model_arguments_properties_load(pd);
- return pd->properties_array;
+ return eina_hash_iterator_key_new(pd->properties);
}
static void
unsigned int arguments_count;
unsigned int i;
- if (pd->properties_array)
- return;
+ if (eina_hash_population(pd->properties) > 0)
+ return ;
arguments_count = eina_list_count(pd->arguments);
- pd->properties_array = eina_array_new(arguments_count);
- EINA_SAFETY_ON_NULL_RETURN(pd->properties_array);
-
for (i = 0; i < arguments_count; ++i)
{
Eldbus_Introspection_Argument *arg;
const Eina_Value_Type *type;
- Eina_Stringshare *name;
+ Eina_Slstr *name;
Eina_Value *value;
- name = eina_stringshare_printf(ARGUMENT_FORMAT, i);
+ name = eina_slstr_printf(ARGUMENT_FORMAT, i);
if (!name) continue;
- eina_array_push(pd->properties_array, name);
-
arg = eina_list_nth(pd->arguments, i);
type = _dbus_type_to_eina_value_type(arg->type[0]);
value = eina_value_new(type);
- eina_hash_add(pd->properties_hash, name, value);
+ eina_hash_add(pd->properties, name, value);
}
}
if (!ret) goto on_error;
err = EFL_MODEL_ERROR_NOT_FOUND;
- prop_value = eina_hash_find(pd->properties_hash, property);
+ prop_value = eina_hash_find(pd->properties, property);
if (!prop_value) goto on_error;
eina_value_flush(prop_value);
_eldbus_model_arguments_properties_load(pd);
- value = eina_hash_find(pd->properties_hash, property);
+ value = eina_hash_find(pd->properties, property);
if (!value) return eina_value_error_new(EFL_MODEL_ERROR_NOT_FOUND);
ret = _eldbus_model_arguments_is_output_argument(pd, property);
EINA_LIST_FREE(pd->pending_list, pending)
eldbus_pending_cancel(pending);
- if (pd->properties_array)
- {
- Eina_Stringshare *property;
- Eina_Array_Iterator it;
- unsigned int i;
-
- EINA_ARRAY_ITER_NEXT(pd->properties_array, i, property, it)
- eina_stringshare_del(property);
- eina_array_free(pd->properties_array);
- pd->properties_array = NULL;
- }
-
- eina_hash_free_buckets(pd->properties_hash);
+ eina_hash_free_buckets(pd->properties);
}
Eina_Bool
Eina_Value *value_struct;
Eina_Array *changed_properties;
unsigned int i = 0;
+ Eina_Stringshare *property;
Eina_Bool result = EINA_FALSE;
_eldbus_model_arguments_properties_load(pd);
{
if (ELDBUS_INTROSPECTION_ARGUMENT_DIRECTION_IN != argument->direction)
{
- Eina_Stringshare *property;
Eina_Bool ret;
- property = eina_array_data_get(pd->properties_array, i);
- EINA_SAFETY_ON_NULL_GOTO(property, on_error);
+ property = eina_stringshare_printf(ARGUMENT_FORMAT, i);
- ret = _eldbus_model_arguments_property_set(pd, value_struct, property);
+ ret = eina_array_push(changed_properties, property);
EINA_SAFETY_ON_FALSE_GOTO(ret, on_error);
- ret = eina_array_push(changed_properties, property);
+ ret = _eldbus_model_arguments_property_set(pd, value_struct, property);
EINA_SAFETY_ON_FALSE_GOTO(ret, on_error);
}
result = EINA_TRUE;
on_error:
+ while (property = eina_array_pop(changed_properties))
+ eina_stringshare_del(property);
eina_array_free(changed_properties);
eina_value_free(value_struct);
_eldbus_model_arguments_properties_load(pd);
- prop_value = eina_hash_find(pd->properties_hash, property);
+ prop_value = eina_hash_find(pd->properties, property);
EINA_SAFETY_ON_NULL_RETURN_VAL(prop_value, EINA_FALSE);
ret = eina_value_struct_value_get(value_struct, "arg0", &value);
_eldbus_model_arguments_properties_load(pd);
i = _eldbus_model_arguments_argument_index_get(pd, argument);
- if (i >= eina_array_count(pd->properties_array))
+ if (i >= eina_hash_population(pd->properties))
{
WRN("Argument not found: %s", argument);
return false;
Eina_Stringshare *name;
Eina_Array_Iterator it;
unsigned int i = 0;
- _eldbus_model_arguments_properties_load(pd);
-
- EINA_ARRAY_ITER_NEXT(pd->properties_array, i, name, it)
- {
- if (strcmp(name, argument) == 0)
- return i;
- }
- return ++i;
+ if (sscanf(argument, ARGUMENT_FORMAT, &i) > 0)
+ return i;
+ return eina_hash_population(pd->properties);
}
#include "eldbus_model_arguments.eo.c"
{
Eo *obj;
Eldbus_Proxy *proxy;
- Eina_Array *properties_array;
- Eina_Hash *properties_hash;
+ Eina_Hash *properties;
Eina_Stringshare *name;
Eina_List *pending_list;
const Eina_List *arguments;
Eina_Bool eldbus_model_arguments_process_arguments(Eldbus_Model_Arguments_Data *, const Eldbus_Message *, Eldbus_Pending *);
+#define ARGUMENT_FORMAT "arg%u"
+
#endif
EINA_LIST_FOREACH(data->arguments, it, argument)
{
- Eina_Stringshare *name;
+ Eina_Slstr *name;
const Eina_Value *value;
const char *signature;
Eina_Bool ret;
if (ELDBUS_INTROSPECTION_ARGUMENT_DIRECTION_IN != argument->direction)
continue;
- name = eina_array_data_get(data->properties_array, i);
- if (!name) continue;
+ name = eina_slstr_printf(ARGUMENT_FORMAT, i);
EINA_SAFETY_ON_NULL_GOTO(name, on_error);
- value = eina_hash_find(data->properties_hash, name);
+ value = eina_hash_find(data->properties, name);
EINA_SAFETY_ON_NULL_GOTO(value, on_error);
signature = argument->type;
efl_destructor(efl_super(obj, MY_CLASS));
}
-static Eina_Array *
+static Eina_Iterator *
_eldbus_model_proxy_efl_model_properties_get(const Eo *obj EINA_UNUSED,
Eldbus_Model_Proxy_Data *pd)
{
- Eina_Iterator *it;
- Eina_Array *r;
- Eina_Stringshare *property;
-
- r = eina_array_new(4);
-
- it = eina_hash_iterator_key_new(pd->properties);
- EINA_ITERATOR_FOREACH(it, property)
- eina_array_push(r, property);
- eina_iterator_free(it);
-
- return r;
+ return eina_hash_iterator_key_new(pd->properties);
}
#define PROPERTY_EXIST 1
static Eina_Bool
_efl_model_properties_has(Efl_Model *model, Eina_Stringshare *propfind)
{
- const Eina_Array *properties;
- Eina_Array_Iterator iter_prop;
- Eina_Stringshare *property;
+ Eina_Iterator *properties;
+ const char *property;
Eina_Bool ret = EINA_FALSE;
- unsigned i = 0;
EINA_SAFETY_ON_NULL_RETURN_VAL(model, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(propfind, EINA_FALSE);
properties = efl_model_properties_get(model);
-
- EINA_ARRAY_ITER_NEXT(properties, i, property, iter_prop)
+ EINA_ITERATOR_FOREACH(properties, property)
{
- if (property == propfind)
+ if (property == propfind ||
+ !strcmp(property, propfind))
{
ret = EINA_TRUE;
break;
}
}
+ eina_iterator_free(properties);
+
return ret;
}
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = NULL;
+ Eina_Iterator *properties = NULL;
properties = efl_model_properties_get(connection);
ck_assert_ptr_ne(NULL, properties);
const unsigned int expected_properties_count = 1;
- unsigned int actual_properties_count = eina_array_count(properties);
+ unsigned int actual_properties_count = 0;
+ const char *prop;
+
+ EINA_ITERATOR_FOREACH(properties, prop)
+ actual_properties_count++;
+ eina_iterator_free(properties);
+
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
EFL_END_TEST
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = NULL;
+ Eina_Iterator *properties = NULL;
properties = efl_model_properties_get(method);
ck_assert_ptr_ne(NULL, properties);
const unsigned int expected_properties_count = 3; // a, b and result arguments of 'sum' method
- const unsigned int actual_properties_count = eina_array_count(properties);
+ unsigned int actual_properties_count = 0;
+ const char *prop;
+
+ EINA_ITERATOR_FOREACH(properties, prop)
+ actual_properties_count++;
+ eina_iterator_free(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
EFL_END_TEST
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = NULL;
+ Eina_Iterator *properties = NULL;
properties = efl_model_properties_get(object);
ck_assert_ptr_ne(NULL, properties);
const unsigned int expected_properties_count = 1;
- unsigned int actual_properties_count = eina_array_count(properties);
+ unsigned int actual_properties_count = 0;
+ const char *prop;
+
+ EINA_ITERATOR_FOREACH(properties, prop)
+ actual_properties_count++;
+ eina_iterator_free(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
EFL_END_TEST
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = NULL;
+ Eina_Iterator *properties = NULL;
// ELDBUS_FDO_INTERFACE have no properties
properties = efl_model_properties_get(dbus_proxy);
ck_assert_ptr_ne(NULL, properties);
// due to an EFL change, but a change in the DBus interface:
// properties contains 2 properties, "Interfaces" and "Features".
//ck_assert_int_eq(0, eina_array_count(properties));
+ eina_iterator_free(properties);
}
EFL_END_TEST
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = NULL;
+ Eina_Iterator *properties = NULL;
properties = efl_model_properties_get(pong_signal);
ck_assert_ptr_ne(NULL, properties);
const unsigned int expected_properties_count = 1; // 'response' only
- const unsigned int actual_properties_count = eina_array_count(properties);
+ unsigned int actual_properties_count = 0;
+ const char *prop;
+
+ EINA_ITERATOR_FOREACH(properties, prop)
+ actual_properties_count += 1;
+ eina_iterator_free(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
EFL_END_TEST
EFL_START_TEST(properties_get)
{
- const Eina_Array *properties = efl_model_properties_get(fake_server_proxy);
+ Eina_Iterator *properties = efl_model_properties_get(fake_server_proxy);
ck_assert_ptr_ne(NULL, properties);
// FAKE_SERVER_READONLY_PROPERTY, FAKE_SERVER_WRITEONLY_PROPERTY and FAKE_SERVER_READWRITE_PROPERTY properties
const unsigned int expected_properties_count = 3;
- const unsigned int actual_properties_count = eina_array_count(properties);
+ unsigned int actual_properties_count = 0;
+ const char *prop;
+
+ EINA_ITERATOR_FOREACH(properties, prop)
+ actual_properties_count++;
+ eina_iterator_free(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
_teardown();