EAPI Eina_Iterator *
eina_array_iterator_new(const Eina_Array *array)
{
Eina_Iterator_Array *it;
EINA_SAFETY_ON_NULL_RETURN_VAL(array, NULL);
EINA_MAGIC_CHECK_ARRAY(array);
eina_error_set(0);
it = calloc(1, sizeof (Eina_Iterator_Array));
if (!it)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_ARRAY_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->array = array;
it->iterator.version = EINA_ITERATOR_VERSION;
it->iterator.next = FUNC_ITERATOR_NEXT(eina_array_iterator_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(
eina_array_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(eina_array_iterator_free);
return &it->iterator;
}
EAPI Eina_Iterator *
eina_inarray_iterator_reversed_new(const Eina_Inarray *array)
{
Eina_Iterator_Inarray *it;
EINA_MAGIC_CHECK_INARRAY(array, NULL);
eina_error_set(0);
it = calloc(1, sizeof(Eina_Iterator_Inarray));
if (!it)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_INARRAY_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->array = array;
it->pos = array->len;
it->iterator.version = EINA_ITERATOR_VERSION;
it->iterator.next = FUNC_ITERATOR_NEXT(_eina_inarray_iterator_prev);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER
(_eina_inarray_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(_eina_inarray_iterator_free);
return &it->iterator;
}
EAPI Eina_Accessor *
eina_inarray_accessor_new(const Eina_Inarray *array)
{
Eina_Accessor_Inarray *ac;
EINA_MAGIC_CHECK_INARRAY(array, NULL);
eina_error_set(0);
ac = calloc(1, sizeof(Eina_Accessor_Inarray));
if (!ac)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(ac, EINA_MAGIC_INARRAY_ACCESSOR);
EINA_MAGIC_SET(&ac->accessor, EINA_MAGIC_ACCESSOR);
ac->array = array;
ac->accessor.version = EINA_ACCESSOR_VERSION;
ac->accessor.get_at = FUNC_ACCESSOR_GET_AT(_eina_inarray_accessor_get_at);
ac->accessor.get_container = FUNC_ACCESSOR_GET_CONTAINER
(_eina_inarray_accessor_get_container);
ac->accessor.free = FUNC_ACCESSOR_FREE(_eina_inarray_accessor_free);
return &ac->accessor;
}
static void
_eina_matrixsparse_iterator_free(Eina_Matrixsparse_Iterator *it)
{
EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it);
EINA_MAGIC_SET(it, EINA_MAGIC_NONE);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_NONE);
free(it);
}
pilot *
pilot_new(const char *name, const char *callsign)
{
pilot *ptr = malloc(sizeof(pilot));
EINA_MAGIC_SET(ptr, SUBTYPE_MAGIC);
EINA_MAGIC_SET(&ptr->base, BASETYPE_MAGIC);
ptr->base.name = strdup(name);
ptr->callsign = strdup(callsign);
}
static void
_eina_matrixsparse_iterator_complete_free(Eina_Matrixsparse_Iterator_Complete *it)
{
EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it);
if (it->dummy.col.data != NULL)
ERR("Last iterator call changed dummy cell!");
EINA_MAGIC_SET(it, EINA_MAGIC_NONE);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_NONE);
free(it);
}
void
pilot_free(pilot *ptr) {
if (!EINA_MAGIC_CHECK(ptr, SUBTYPE_MAGIC))
{
EINA_MAGIC_FAIL(ptr, SUBTYPE_MAGIC);
return;
}
EINA_MAGIC_SET(ptr, EINA_MAGIC_NONE);
EINA_MAGIC_SET(&ptr->base, EINA_MAGIC_NONE);
free(ptr->base.name);
free(ptr->callsign);
free(ptr);
}
/**
* @brief Returns a new iterator associated to @a list.
*
* @param list The list.
* @return A new iterator.
*
* This function returns a newly allocated iterator associated to @p
* list. If @p list is @c NULL or the count member of @p list is less
* or equal than 0, this function still returns a valid iterator that
* will always return false on eina_iterator_next(), thus keeping API
* sane.
*
* If the memory can not be allocated, NULL is returned and
* #EINA_ERROR_OUT_OF_MEMORY is set. Otherwise, a valid iterator is
* returned.
*
* @warning if the list structure changes then the iterator becomes
* invalid, and if you add or remove nodes iterator
* behavior is undefined, and your program may crash!
*/
EAPI Eina_Iterator *
eina_inlist_iterator_new(const Eina_Inlist *list)
{
Eina_Iterator_Inlist *it;
eina_error_set(0);
it = calloc(1, sizeof (Eina_Iterator_Inlist));
if (!it)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
it->head = list;
it->current = list;
it->iterator.version = EINA_ITERATOR_VERSION;
it->iterator.next = FUNC_ITERATOR_NEXT(eina_inlist_iterator_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(
eina_inlist_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(eina_inlist_iterator_free);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
return &it->iterator;
}
person *
person_new(const char *name)
{
person *ptr = malloc(sizeof(person));
EINA_MAGIC_SET(ptr, BASETYPE_MAGIC);
ptr->name = strdup(name);
}
EAPI Eina_Simple_XML_Node_Tag *
eina_simple_xml_node_tag_new(Eina_Simple_XML_Node_Tag *parent, const char *name)
{
Eina_Simple_XML_Node_Tag *n;
if (!name) return NULL;
n = eina_mempool_malloc(_eina_simple_xml_tag_mp, sizeof(*n));
if (!n)
{
ERR("could not allocate memory for node from mempool");
return NULL;
}
memset(n, 0, sizeof(*n));
EINA_MAGIC_SET(&n->base, EINA_MAGIC_SIMPLE_XML_TAG);
n->base.type = EINA_SIMPLE_XML_NODE_TAG;
n->base.parent = parent;
n->name = eina_stringshare_add(name);
if (parent)
parent->children = eina_inlist_append
(parent->children, EINA_INLIST_GET(&n->base));
return n;
}
EAPI Eina_Simple_XML_Attribute *
eina_simple_xml_attribute_new(Eina_Simple_XML_Node_Tag *parent, const char *key, const char *value)
{
Eina_Simple_XML_Attribute *attr;
if (!key) return NULL;
attr = eina_mempool_malloc(_eina_simple_xml_attribute_mp, sizeof(*attr));
if (!attr)
{
ERR("could not allocate memory for attribute from mempool");
return NULL;
}
EINA_MAGIC_SET(attr, EINA_MAGIC_SIMPLE_XML_ATTRIBUTE);
attr->parent = parent;
attr->key = eina_stringshare_add(key);
attr->value = eina_stringshare_add(value ? value : "");
if (parent)
parent->attributes = eina_inlist_append
(parent->attributes, EINA_INLIST_GET(attr));
return attr;
}
/**
* @brief Create a new Sparse Matrix.
*
* @param rows number of rows in matrix. Operations with rows greater than this
* value will fail.
* @param cols number of columns in matrix. Operations with columns greater
* than this value will fail.
* @param free_func used to delete cell data contents, used by
* eina_matrixsparse_free(), eina_matrixsparse_size_set(),
* eina_matrixsparse_row_idx_clear(),
* eina_matrixsparse_column_idx_clear(),
* eina_matrixsparse_cell_idx_clear() and possible others.
* @param user_data given to @a free_func as first parameter.
*
* @return newly allocated matrix or NULL if allocation failed and eina_error
* is set.
*/
EAPI Eina_Matrixsparse *
eina_matrixsparse_new(unsigned long rows, unsigned long cols, void (*free_func)(void *user_data, void *cell_data), const void *user_data)
{
Eina_Matrixsparse *m;
EINA_SAFETY_ON_FALSE_RETURN_VAL(rows > 0, NULL);
EINA_SAFETY_ON_FALSE_RETURN_VAL(cols > 0, NULL);
m = malloc(sizeof(Eina_Matrixsparse));
if (!m)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
m->rows = NULL;
m->last_row = NULL;
m->last_used = NULL;
m->size.rows = rows;
m->size.cols = cols;
m->free.func = free_func;
m->free.user_data = (void *)user_data;
EINA_MAGIC_SET(m, EINA_MAGIC_MATRIXSPARSE);
eina_error_set(0);
return m;
}
static Eina_Simple_XML_Node_Data *
_eina_simple_xml_node_data_new(Eina_Simple_XML_Node_Tag *parent, Eina_Simple_XML_Node_Type type, const char *content, unsigned length)
{
Eina_Simple_XML_Node_Data *n;
if (!content) return NULL;
n = malloc(sizeof(*n) + length + 1);
if (!n)
{
ERR("could not allocate memory for node");
return NULL;
}
EINA_MAGIC_SET(&n->base, EINA_MAGIC_SIMPLE_XML_DATA);
n->base.type = type;
n->base.parent = parent;
n->length = length;
memcpy(n->data, content, length);
n->data[length] = '\0';
if (parent)
parent->children = eina_inlist_append
(parent->children, EINA_INLIST_GET(&n->base));
return n;
}
static inline void
_eina_matrixsparse_row_free(Eina_Matrixsparse_Row *r, void (*free_func)(void *, void *), void *user_data)
{
_eina_matrixsparse_row_cells_free(r, free_func, user_data);
EINA_MAGIC_SET(r, EINA_MAGIC_NONE);
eina_mempool_free(_eina_matrixsparse_row_mp, r);
}
/**
* @brief Returns a new accessor associated to a list.
*
* @param list The list.
* @return A new accessor.
*
* This function returns a newly allocated accessor associated to
* @p list. If @p list is @c NULL or the count member of @p list is
* less or equal than 0, this function returns NULL. If the memory can
* not be allocated, NULL is returned and #EINA_ERROR_OUT_OF_MEMORY is
* set. Otherwise, a valid accessor is returned.
*/
EAPI Eina_Accessor *
eina_inlist_accessor_new(const Eina_Inlist *list)
{
Eina_Accessor_Inlist *ac;
eina_error_set(0);
ac = calloc(1, sizeof (Eina_Accessor_Inlist));
if (!ac)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
ac->head = list;
ac->current = list;
ac->index = 0;
ac->accessor.version = EINA_ACCESSOR_VERSION;
ac->accessor.get_at = FUNC_ACCESSOR_GET_AT(eina_inlist_accessor_get_at);
ac->accessor.get_container = FUNC_ACCESSOR_GET_CONTAINER(
eina_inlist_accessor_get_container);
ac->accessor.free = FUNC_ACCESSOR_FREE(eina_inlist_accessor_free);
EINA_MAGIC_SET(&ac->accessor, EINA_MAGIC_ACCESSOR);
return &ac->accessor;
}
void
_eina_simple_xml_node_tag_free(Eina_Simple_XML_Node_Tag *tag)
{
while (tag->children)
{
Eina_Simple_XML_Node *n = EINA_INLIST_CONTAINER_GET
(tag->children, Eina_Simple_XML_Node);
if (n->type == EINA_SIMPLE_XML_NODE_TAG)
_eina_simple_xml_node_tag_free((Eina_Simple_XML_Node_Tag *)n);
else
_eina_simple_xml_node_data_free((Eina_Simple_XML_Node_Data *)n);
}
while (tag->attributes)
{
Eina_Simple_XML_Attribute *a = EINA_INLIST_CONTAINER_GET
(tag->attributes, Eina_Simple_XML_Attribute);
eina_simple_xml_attribute_free(a);
}
if (tag->base.parent)
tag->base.parent->children = eina_inlist_remove
(tag->base.parent->children, EINA_INLIST_GET(&tag->base));
eina_stringshare_del(tag->name);
EINA_MAGIC_SET(&tag->base, EINA_MAGIC_NONE);
eina_mempool_free(_eina_simple_xml_tag_mp, tag);
}
static inline void
_eina_list_mempool_accounting_free(Eina_List_Accounting *accounting)
{
EINA_MAGIC_CHECK_LIST_ACCOUNTING(accounting);
EINA_MAGIC_SET(accounting, EINA_MAGIC_NONE);
eina_mempool_free(_eina_list_accounting_mp, accounting);
}
static inline void
_eina_matrixsparse_cell_free(Eina_Matrixsparse_Cell *c, void (*free_func)(void *, void *), void *user_data)
{
if (free_func)
free_func(user_data, c->data);
EINA_MAGIC_SET(c, EINA_MAGIC_NONE);
eina_mempool_free(_eina_matrixsparse_cell_mp, c);
}
/*
* On success @param msg is unref'd or its ref is stolen by the returned
* Eldbus_Pending.
*/
Eldbus_Pending *
_eldbus_connection_send(Eldbus_Connection *conn, Eldbus_Message *msg, Eldbus_Message_Cb cb, const void *cb_data, double timeout)
{
Eldbus_Pending *pending;
Eldbus_Message *error_msg;
DBG("conn=%p, msg=%p, cb=%p, cb_data=%p, timeout=%f",
conn, msg, cb, cb_data, timeout);
if (!cb)
{
dbus_connection_send(conn->dbus_conn, msg->dbus_msg, NULL);
eldbus_message_unref(msg);
return NULL;
}
pending = calloc(1, sizeof(Eldbus_Pending));
EINA_SAFETY_ON_NULL_RETURN_VAL(pending, NULL);
pending->cb = cb;
pending->cb_data = cb_data;
pending->conn = conn;
pending->dest = eina_stringshare_add(dbus_message_get_destination(msg->dbus_msg));
pending->interface = eina_stringshare_add(dbus_message_get_interface(msg->dbus_msg));
pending->method = eina_stringshare_add(dbus_message_get_member(msg->dbus_msg));
pending->path = eina_stringshare_add(dbus_message_get_path(msg->dbus_msg));
/* Steal the reference */
pending->msg_sent = msg;
EINA_MAGIC_SET(pending, ELDBUS_PENDING_MAGIC);
if (!dbus_connection_send_with_reply(conn->dbus_conn,
msg->dbus_msg,
&pending->dbus_pending, timeout))
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.NoConnection",
"Eldbus_Connection was closed.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (!pending->dbus_pending)
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.Error",
"dbus_pending is NULL.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (dbus_pending_call_set_notify(pending->dbus_pending, cb_pending, pending, NULL))
return pending;
dbus_pending_call_cancel(pending->dbus_pending);
error_msg = _eldbus_message_error_get(pending->msg_sent,
"org.enlightenment.DBus.Error",
"Error when try set callback to message.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
static void
_eina_simple_xml_node_data_free(Eina_Simple_XML_Node_Data *node)
{
if (node->base.parent)
node->base.parent->children = eina_inlist_remove
(node->base.parent->children, EINA_INLIST_GET(&node->base));
EINA_MAGIC_SET(&node->base, EINA_MAGIC_NONE);
free(node);
}
void
person_free(person *ptr) {
if (!EINA_MAGIC_CHECK(ptr, BASETYPE_MAGIC))
{
EINA_MAGIC_FAIL(ptr, BASETYPE_MAGIC);
return;
}
EINA_MAGIC_SET(ptr, EINA_MAGIC_NONE);
free(ptr->name);
free(ptr);
}
static void
_eina_inarray_setup(Eina_Inarray *array, unsigned int member_size, unsigned int step)
{
EINA_MAGIC_SET(array, EINA_MAGIC_INARRAY);
array->version = EINA_ARRAY_VERSION;
array->member_size = member_size;
array->len = 0;
array->max = 0;
array->step = (step > 0) ? step : 32;
array->members = NULL;
}
static inline void
_eina_list_mempool_list_free(Eina_List *list)
{
EINA_MAGIC_CHECK_LIST(list);
list->accounting->count--;
if (list->accounting->count == 0)
_eina_list_mempool_accounting_free(list->accounting);
EINA_MAGIC_SET(list, EINA_MAGIC_NONE);
eina_mempool_free(_eina_list_mp, list);
}
static void
_array_iterator_free(Eina_Iterator *iterator)
{
struct Array_Iterator *it = (struct Array_Iterator *)iterator;
if (!EINA_MAGIC_CHECK(iterator, EINA_MAGIC_ITERATOR))
{
EINA_MAGIC_FAIL(iterator, EINA_MAGIC_ITERATOR);
return;
}
EINA_MAGIC_SET(&it->base, EINA_MAGIC_NONE);
free(it);
}
static Eldbus_Message_Iter *
_message_iterator_new(Eina_Bool writable)
{
Eldbus_Message_Iter *iter;
iter = calloc(1, sizeof(Eldbus_Message_Iter));
EINA_SAFETY_ON_NULL_RETURN_VAL(iter, NULL);
EINA_MAGIC_SET(iter, ELDBUS_MESSAGE_ITERATOR_MAGIC);
iter->writable = writable;
return iter;
}
static inline Eina_List *
_eina_list_mempool_list_new(EINA_UNUSED Eina_List *list)
{
Eina_List *tmp;
tmp = eina_mempool_malloc(_eina_list_mp, sizeof (Eina_List));
if (!tmp)
return NULL;
EINA_MAGIC_SET(tmp, EINA_MAGIC_LIST);
return tmp;
}
EAPI void
eina_simple_xml_attribute_free(Eina_Simple_XML_Attribute *attr)
{
EINA_MAGIC_CHECK_ATTRIBUTE(attr);
if (attr->parent)
attr->parent->attributes = eina_inlist_remove
(attr->parent->attributes, EINA_INLIST_GET(attr));
eina_stringshare_del(attr->key);
eina_stringshare_del(attr->value);
EINA_MAGIC_SET(attr, EINA_MAGIC_NONE);
eina_mempool_free(_eina_simple_xml_attribute_mp, attr);
}
EAPI Eina_Iterator *
eina_inarray_iterator_new(const Eina_Inarray *array)
{
Eina_Iterator_Inarray *it;
EINA_MAGIC_CHECK_INARRAY(array, NULL);
it = calloc(1, sizeof(Eina_Iterator_Inarray));
if (!it) return NULL;
EINA_MAGIC_SET(it, EINA_MAGIC_INARRAY_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->array = array;
it->iterator.version = EINA_ITERATOR_VERSION;
it->iterator.next = FUNC_ITERATOR_NEXT(_eina_inarray_iterator_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER
(_eina_inarray_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(_eina_inarray_iterator_free);
return &it->iterator;
}
static Eina_Iterator *
_array_iterator_new(const void *array, size_t item_size, size_t count)
{
struct Array_Iterator *it = calloc(1, sizeof(*it));
EINA_SAFETY_ON_NULL_RETURN_VAL(it, NULL);
it->base.get_container = _array_iterator_container_get;
it->base.free = _array_iterator_free;
it->base.next = _array_iterator_next;
it->container = array;
it->item_size = item_size;
it->count = count;
EINA_MAGIC_SET(&it->base, EINA_MAGIC_ITERATOR);
return &it->base;
}
static inline Eina_Matrixsparse_Row *
_eina_matrixsparse_row_idx_add(Eina_Matrixsparse *m, unsigned long row)
{
Eina_Matrixsparse_Row *r = eina_mempool_malloc
(_eina_matrixsparse_row_mp, sizeof(Eina_Matrixsparse_Row));
if (!r) return NULL;
if (!m->rows)
{
r->prev = NULL;
r->next = NULL;
m->rows = r;
m->last_row = r;
}
else if (row < m->rows->row)
{
r->prev = NULL;
r->next = m->rows;
m->rows->prev = r;
m->rows = r;
}
else if (row > m->last_row->row)
{
r->prev = m->last_row;
m->last_row->next = r;
r->next = NULL;
m->last_row = r;
}
else
{
Eina_Matrixsparse_Row *prev = NULL, *next = NULL;
_eina_matrixsparse_row_idx_siblings_find(m, row, &prev, &next);
assert(prev != NULL);
assert(next != NULL);
r->prev = prev;
r->next = next;
prev->next = r;
next->prev = r;
}
r->cols = NULL;
r->last_col = NULL;
r->last_used = NULL;
r->row = row;
r->parent = m;
EINA_MAGIC_SET(r, EINA_MAGIC_MATRIXSPARSE_ROW);
m->last_used = r;
return r;
}
