static void
_fill_receive_array_of_string_int_with_size(Eldbus_Message *msg, int size, const char *array[])
{
Eina_Value *value_struct, *value_array;
int i;
unsigned offset;
Eina_Value_Struct_Member main_members[2];
Eina_Value_Struct_Member sub_members[] = {
EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_STRING, sub_struct, txt),
EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, sub_struct, num)
};
Eina_Value_Struct_Desc desc_sub_struct = {
EINA_VALUE_STRUCT_DESC_VERSION,
NULL, // no special operations
sub_members,
2,
sizeof(sub_struct)
};
Eina_Value_Struct_Desc desc_struct = {
EINA_VALUE_STRUCT_DESC_VERSION,
NULL, // no special operations
main_members,
2,
0//will be set below
};
offset = _type_offset(sizeof(int), sizeof(Eina_Value_Array));
main_members[0].name = "size";
main_members[0].type = EINA_VALUE_TYPE_INT, 0;
main_members[0].offset = 0;
main_members[1].name = "array";
main_members[1].type = EINA_VALUE_TYPE_ARRAY;
main_members[1].offset = offset;
desc_struct.size = offset + sizeof(Eina_Value_Array);
value_struct = eina_value_struct_new(&desc_struct);
eina_value_struct_set(value_struct, "size", size);
value_array = eina_value_array_new(EINA_VALUE_TYPE_STRUCT, size);
for (i = 0; i < size; i++)
{
Eina_Value *value_sub_struct = eina_value_struct_new(&desc_sub_struct);
Eina_Value_Struct st;
eina_value_struct_set(value_sub_struct, "txt", array[i]);
eina_value_struct_set(value_sub_struct, "num", i);
eina_value_get(value_sub_struct, &st);
eina_value_array_append(value_array, st);
eina_value_free(value_sub_struct);
}
eina_value_struct_value_set(value_struct, "array", value_array);
eldbus_message_from_eina_value("ia(si)", msg, value_struct);
eina_value_free(value_struct);
eina_value_free(value_array);
}
static void
cb_mpris_media_player2_supported_uri_schemes(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
void *user_data = eldbus_pending_data_del(pending, "__user_data");
const char *error, *error_msg;
Eldbus_Codegen_Property_Complex_Get_Cb cb = data;
Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
Eldbus_Message_Iter *variant;
Eina_Value *v, stack_value;
if (eldbus_message_error_get(msg, &error, &error_msg))
{
Eldbus_Error_Info error_info = {error, error_msg};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
if (!eldbus_message_arguments_get(msg, "v", &variant))
{
Eldbus_Error_Info error_info = {"", ""};
cb(user_data, pending, "SupportedUriSchemes", proxy, &error_info, NULL);
return;
}
v = eldbus_message_iter_struct_like_to_eina_value(variant);
eina_value_struct_value_get(v, "arg0", &stack_value);
cb(user_data, pending, "SupportedUriSchemes", proxy, NULL, &stack_value);
eina_value_flush(&stack_value);
eina_value_free(v);
}
int main(int argc, char **argv)
{
Eina_Value *v1, *v2;
eina_init();
value_init();
srand(time(NULL));
v1 = eina_value_struct_new(V1_DESC);
v2 = eina_value_struct_new(V2_DESC);
rand_init(v1);
my_struct_use(v1);
rand_init(v2);
my_struct_use(v2);
eina_value_free(v1);
eina_value_free(v2);
eina_shutdown();
}
static Eina_Value *
azy_value_deserialize_array_json(cJSON *object)
{
Eina_Value *arr;
const Eina_Value_Type *type;
int x = 0;
cJSON *child;
child = cJSON_GetArrayItem(object, 0);
if (!child)
return eina_value_array_new(EINA_VALUE_TYPE_STRING, 0);
type = _azy_value_type_get(child);
arr = eina_value_array_new(type, 0);
for (; x < cJSON_GetArraySize(object); x++)
{
if (x)
{
child = cJSON_GetArrayItem(object, x);
if(_azy_value_type_get(child) != type)
{
EINA_LOG_ERR("We have different type of data in array.");
continue;
}
}
if (type == EINA_VALUE_TYPE_ARRAY)
{
Eina_Value_Array inner_array;
Eina_Value *data = azy_value_deserialize_array_json(child);
if (!data) goto error;
eina_value_get(data, &inner_array);
eina_value_array_append(arr, inner_array);
}
else if (type == EINA_VALUE_TYPE_STRUCT)
{
Eina_Value_Struct st;
Eina_Value *data = azy_value_deserialize_struct_json(child);
if (!data) goto error;
eina_value_get(data, &st);
eina_value_array_append(arr, st);
}
else
{
if (!azy_value_deserialize_basic_json(child, arr)) goto error;
}
}
return arr;
error:
eina_value_free(arr);
return NULL;
}
static Eina_Value *
azy_value_deserialize_struct_json(cJSON *object)
{
Eina_Array *st_members, *st_values;
unsigned int offset = 0, z = 0;
Eina_Value *value_st = NULL;
Eina_Value_Struct_Member *members;
Eina_Value_Struct_Desc *st_desc;
const char *name;
cJSON *child;
st_desc = azy_value_util_struct_desc_new();
st_members = eina_array_new(1);
st_values = eina_array_new(1);
for (child = object->child; child; child = child->next)
{
Eina_Value_Struct_Member *m;
const Eina_Value_Type *type;
Eina_Value *v;
type = _azy_value_type_get(child);
if (!type) goto end;
name = child->string;
m = (Eina_Value_Struct_Member*)calloc(1, sizeof(Eina_Value_Struct_Member));
m->name = eina_stringshare_add(name);
offset = azy_value_util_type_offset(type, offset);
m->offset = offset;
offset += azy_value_util_type_size(type);
m->type = type;
eina_array_push(st_members, m);
v = azy_value_deserialize_json(child);
if (!v) goto end;
eina_array_push(st_values, v);
z++;
}
if (!z)
{
free(st_desc);
goto end;
}
members = (Eina_Value_Struct_Member*)malloc(eina_array_count(st_members) * sizeof(Eina_Value_Struct_Member));
for (z = 0; z < eina_array_count(st_members); z++)
{
Eina_Value_Struct_Member *m = (Eina_Value_Struct_Member*)eina_array_data_get(st_members, z);
members[z].name = m->name;
members[z].offset = m->offset;
members[z].type = m->type;
free(m);
}
//setup
st_desc->members = members;
st_desc->member_count = eina_array_count(st_members);
st_desc->size = offset;
value_st = eina_value_struct_new(st_desc);
//filling with data
for (z = 0; z < eina_array_count(st_values); z++)
{
Eina_Value *v = (Eina_Value*)eina_array_data_get(st_values, z);
eina_value_struct_value_set(value_st, members[z].name, v);
eina_value_free(v);
}
end:
eina_array_free(st_members);
eina_array_free(st_values);
return value_st;
}
static void
_eldbus_model_arguments_hash_free(Eina_Value *value)
{
eina_value_free(value);
}
