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)); }