static void
deserialize_sinks_watcher(Pulse *conn, Pulse_Tag *tag)
{
pa_subscription_event_type_t e;
uint32_t idx;
EINA_SAFETY_ON_FALSE_RETURN(untag_uint32(tag, &e));
EINA_SAFETY_ON_FALSE_RETURN(untag_uint32(tag, &idx));
if (e & PA_SUBSCRIPTION_EVENT_CHANGE)
{
Pulse_Sink *sink;
sink = eina_hash_find(pulse_sinks, &idx);
if (sink)
{
if (pulse_sink_get(conn, idx))
sink->update = EINA_TRUE;
}
else
{
sink = eina_hash_find(pulse_sources, &idx);
if (!sink) return;
if (pulse_source_get(conn, idx))
sink->update = EINA_TRUE;
}
}
}
EAPI void
eldbus_message_iter_dict_iterate(Eldbus_Message_Iter *array, const char *signature, Eldbus_Dict_Cb_Get cb, const void *data)
{
Eldbus_Message_Iter *entry;
char *iter_sig;
unsigned len;
EINA_SAFETY_ON_FALSE_RETURN(array);
EINA_SAFETY_ON_NULL_RETURN(signature);
iter_sig = eldbus_message_iter_signature_get(array);
len = strlen(iter_sig + 1);
if (strncmp(signature, iter_sig + 1, len - 1))
{
ERR("Unexpected signature, expected is: %s", iter_sig);
free(iter_sig);
return;
}
free(iter_sig);
while (eldbus_message_iter_get_and_next(array, 'e', &entry))
{
const void *key;
Eldbus_Message_Iter *var;
if (!eldbus_message_iter_arguments_get(entry, signature, &key, &var))
continue;
cb((void *)data, key, var);
}
}
/**
* @brief Iterate over the container and execute a callback on chosen elements.
*
* @param accessor The accessor.
* @param cb The callback called on the chosen elements.
* @param start The position of the first element.
* @param end The position of the last element.
* @param fdata The data passed to the callback.
*
* This function iterates over the elements pointed by @p accessor,
* starting from the element at position @p start and ending to the
* element at position @p end. For Each element, the callback
* @p cb is called with the data @p fdata. If @p accessor is @c NULL
* or if @p start is greter or equal than @p end, the function returns
* immediately.
*/
EAPI void
eina_accessor_over(Eina_Accessor *accessor,
Eina_Each_Cb cb,
unsigned int start,
unsigned int end,
const void *fdata)
{
const void *container;
void *data;
unsigned int i;
EINA_MAGIC_CHECK_ACCESSOR(accessor);
EINA_SAFETY_ON_NULL_RETURN(accessor);
EINA_SAFETY_ON_NULL_RETURN(accessor->get_container);
EINA_SAFETY_ON_NULL_RETURN(accessor->get_at);
EINA_SAFETY_ON_NULL_RETURN(cb);
EINA_SAFETY_ON_FALSE_RETURN(start < end);
if (!eina_accessor_lock(accessor))
return ;
container = accessor->get_container(accessor);
for (i = start; i < end && accessor->get_at(accessor, i, &data) == EINA_TRUE;
++i)
if (cb(container, data, (void *)fdata) != EINA_TRUE)
goto on_exit;
on_exit:
(void) eina_accessor_unlock(accessor);
}
void
animal_eat(Eina_Model *m)
{
EINA_SAFETY_ON_FALSE_RETURN(eina_model_instance_check(m, ANIMAL_TYPE));
void (*pf)(Eina_Model *m);
pf = eina_model_method_resolve(m, Animal_Type, eat);
EINA_SAFETY_ON_NULL_RETURN(pf);
printf("%s() \t", __func__);
pf(m);
}
EOLIAN static void
_efl_net_dialer_simple_efl_io_buffered_stream_inner_io_set(Eo *o, Efl_Net_Dialer_Simple_Data *pd, Efl_Object *io)
{
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(io, EFL_NET_DIALER_INTERFACE));
efl_io_buffered_stream_inner_io_set(efl_super(o, MY_CLASS), io);
efl_event_callback_array_add(io, _efl_net_dialer_simple_inner_io_cbs(), o);
/* apply pending dialer values */
if (pd->pending.proxy_url)
{
pd->pending.proxy_url = EINA_FALSE;
efl_net_dialer_proxy_set(io, pd->proxy_url);
eina_stringshare_replace(&pd->proxy_url, NULL);
}
if (pd->pending.dial_timeout)
{
pd->pending.dial_timeout = EINA_FALSE;
efl_net_dialer_timeout_dial_set(io, pd->dial_timeout);
}
/* apply pending io buffered stream (own) values */
if (pd->pending.timeout_inactivity)
{
pd->pending.timeout_inactivity = EINA_FALSE;
efl_io_buffered_stream_timeout_inactivity_set(o, pd->timeout_inactivity);
}
if (pd->pending.max_queue_size_input)
{
pd->pending.max_queue_size_input = EINA_FALSE;
efl_io_buffered_stream_max_queue_size_input_set(o, pd->max_queue_size_input);
}
if (pd->pending.max_queue_size_output)
{
pd->pending.max_queue_size_output = EINA_FALSE;
efl_io_buffered_stream_max_queue_size_output_set(o, pd->max_queue_size_output);
}
if (pd->pending.read_chunk_size)
{
pd->pending.read_chunk_size = EINA_FALSE;
efl_io_buffered_stream_read_chunk_size_set(o, pd->read_chunk_size);
}
if (pd->pending.line_delimiter)
{
pd->pending.line_delimiter = EINA_FALSE;
efl_io_buffered_stream_line_delimiter_set(o, pd->line_delimiter);
free((void *)pd->line_delimiter.mem);
pd->line_delimiter.mem = NULL;
}
}
/**
* @brief Close a client's connection
*
* This function is the opposite of azy_client_connect, it
* terminates an existing connection.
* @param client The client (NOT NULL)
*/
void
azy_client_close(Azy_Client *client)
{
DBG("(client=%p)", client);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return;
}
EINA_SAFETY_ON_FALSE_RETURN(client->connected);
EINA_SAFETY_ON_NULL_RETURN(client->net);
ecore_con_server_del(client->net->conn);
azy_net_free(client->net);
client->net = NULL;
client->connected = EINA_FALSE;
}
static void
esql_postgresql_query(Esql *e, const char *query, unsigned int len __UNUSED__)
{
EINA_SAFETY_ON_FALSE_RETURN(PQsendQuery(e->backend.db, query));
}
