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_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;
}
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;
}
void *data_new()
{
eina_error_set(0);
eina_error_set(MY_ERROR_NULL);
return NULL;
}
/**
* @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;
}
/**
* @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;
}
/**
* @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;
}
static const char *
_eina_stringshare_small_bucket_insert_at(
Eina_Stringshare_Small_Bucket **p_bucket,
const char *str,
unsigned char length,
int idx)
{
Eina_Stringshare_Small_Bucket *bucket = *p_bucket;
int todo, off;
char *snew;
if (!bucket)
{
*p_bucket = bucket = calloc(1, sizeof(*bucket));
if (!bucket)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
}
if (bucket->count + 1 >= bucket->size)
{
int size = bucket->size + EINA_STRINGSHARE_SMALL_BUCKET_STEP;
if (!_eina_stringshare_small_bucket_resize(bucket, size))
return NULL;
}
snew = malloc(length + 1);
if (!snew)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
memcpy(snew, str, length);
snew[length] = '\0';
off = idx + 1;
todo = bucket->count - idx;
if (todo > 0)
{
memmove((void *)(bucket->strings + off), bucket->strings + idx,
todo * sizeof(bucket->strings[0]));
memmove(bucket->lengths + off, bucket->lengths + idx,
todo * sizeof(bucket->lengths[0]));
memmove(bucket->references + off, bucket->references + idx,
todo * sizeof(bucket->references[0]));
}
bucket->strings[idx] = snew;
bucket->lengths[idx] = length;
bucket->references[idx] = 1;
bucket->count++;
return snew;
}
int test(int n)
{
eina_error_set(0);
if (n < 0)
{
eina_error_set(MY_ERROR_NEGATIVE);
return 0;
}
return 1;
}
/**
* @internal
*
* init the buffer
* @param buf the buffer to init
*
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
*/
static Eina_Bool _eina_strbuf_common_init(size_t csize, Eina_Strbuf * buf)
{
buf->len = 0;
buf->size = EINA_STRBUF_INIT_SIZE;
buf->step = EINA_STRBUF_INIT_STEP;
eina_error_set(0);
buf->buf = calloc(csize, buf->size);
if (EINA_UNLIKELY(!buf->buf)) {
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return EINA_FALSE;
}
return EINA_TRUE;
}
static Eina_Mempool *
_new_va(const char *name,
const char *context,
const char *options,
va_list args)
{
Eina_Mempool_Backend *be;
Eina_Mempool *mp;
Eina_Error err = EINA_ERROR_NOT_MEMPOOL_MODULE;
eina_error_set(0);
be = eina_hash_find(_backends, name);
if ((!be) || (!be->init))
goto on_error;
err = EINA_ERROR_OUT_OF_MEMORY;
mp = calloc(1, sizeof(Eina_Mempool));
if (!mp)
goto on_error;
/* Work around ABI incompability introduced in Eina 1.1 */
#define SBP(Property) mp->backend.Property = be->Property;
SBP(name);
SBP(init);
SBP(free);
SBP(alloc);
SBP(realloc);
SBP(garbage_collect);
SBP(statistics);
SBP(shutdown);
#undef SBP
if (be->repack)
{
mp->backend2 = calloc(1, sizeof (Eina_Mempool_Backend_ABI2));
if (mp->backend2)
mp->backend2->repack = be->repack;
}
mp->backend_data = mp->backend.init(context, options, args);
return mp;
on_error:
eina_error_set(err);
return NULL;
}
static Eina_Bool
_eina_inarray_resize(Eina_Inarray *array, unsigned int new_size)
{
unsigned int new_max;
void *tmp;
if (new_size < array->max) /* don't change this behaviour as eina_inarray_pop rely on it */
return EINA_TRUE;
if (new_size % array->step == 0)
new_max = new_size;
else
new_max = ((new_size / array->step) + 1) * array->step;
tmp = realloc(array->members, new_max * array->member_size);
if ((!tmp) && (new_max > 0))
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return EINA_FALSE;
}
array->members = tmp;
array->max = new_max;
return EINA_TRUE;
}
/*
* Constructor for the Eupnp_HTTP_Header structure
*
* Receives pointers to key and value starting points and the length that will
* be copied from that point on (length). The key will be automatically
* converted to lowercase.
*
* @param key starting point of the key
* @param key_len key length
* @param value starting point of the value
* @param value_len value length
*
* @return Eupnp_HTTP_Header instance
*/
Eupnp_HTTP_Header *
eupnp_http_header_new(const char *key, int key_len, const char *value, int value_len)
{
Eupnp_HTTP_Header *h;
/* Alloc blob */
h = malloc(sizeof(Eupnp_HTTP_Header) + key_len + 1 + value_len + 1);
if (!h)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
ERROR("header alloc error.\n");
return NULL;
}
h->key = (char *)h + sizeof(Eupnp_HTTP_Header);
h->value = (char *)h + sizeof(Eupnp_HTTP_Header) + sizeof(char)*(key_len + 1);
memcpy((void *)h->key, key, key_len);
memcpy((void *)h->value, value, value_len);
((char *) h->key)[key_len] = '\0';
((char *) h->value)[value_len] = '\0';
/*
* Make key lowercase - no need to care about case insensitive.
*/
char *p = (char *) h->key;
while (*p != '\0')
{
*p = tolower(*p);
(p)++;
}
return h;
}
/**
* Constructor for the Eupnp_Control_Point class.
*
* @return A new Eupnp_Control_Point instance. On error, returns NULL.
*/
EAPI Eupnp_Control_Point *
eupnp_control_point_new(void)
{
Eupnp_Control_Point *c;
c = malloc(sizeof(Eupnp_Control_Point));
if (!c)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
ERR("Could not allocate a new control point.");
return NULL;
}
c->ssdp_client = eupnp_ssdp_client_new();
if (!c->ssdp_client)
{
ERR("Could not create a ssdp instance for the control point.");
free(c);
return NULL;
}
return c;
}
EAPI Eina_Bool eina_module_load(Eina_Module *m)
{
#ifdef HAVE_DLOPEN
void *dl_handle;
Eina_Module_Init *initcall;
EINA_SAFETY_ON_NULL_RETURN_VAL(m, EINA_FALSE);
DBG("m=%p, handle=%p, file=%s, refs=%d", m, m->handle, m->file, m->ref);
if (m->handle)
goto loaded;
dl_handle = dlopen(m->file, RTLD_NOW);
if (!dl_handle)
{
WRN("could not dlopen(\"%s\", RTLD_NOW): %s", m->file, dlerror());
eina_error_set(EINA_ERROR_WRONG_MODULE);
return EINA_FALSE;
}
initcall = dlsym(dl_handle, EINA_MODULE_SYMBOL_INIT);
if ((!initcall) || (!(*initcall)))
goto ok;
if ((*initcall)() == EINA_TRUE)
goto ok;
WRN("could not find eina's entry symbol %s inside module %s",
EINA_MODULE_SYMBOL_INIT, m->file);
eina_error_set(EINA_ERROR_MODULE_INIT_FAILED);
dlclose(dl_handle);
return EINA_FALSE;
ok:
DBG("successfully loaded %s", m->file);
m->handle = dl_handle;
loaded:
m->ref++;
DBG("ref %d", m->ref);
eina_error_set(0);
return EINA_TRUE;
#else
(void) m;
return EINA_FALSE;
#endif
}
/*============================================================================*
* API *
*============================================================================*/
EAPI Eina_Inarray *
eina_inarray_new(unsigned int member_size, unsigned int step)
{
Eina_Inarray *ret;
EINA_SAFETY_ON_TRUE_RETURN_VAL(member_size == 0, NULL);
ret = malloc(sizeof(*ret));
if (!ret)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
eina_error_set(0);
_eina_inarray_setup(ret, member_size, step);
return ret;
}
/**
* @brief Create a new string buffer.
*
* @return Newly allocated string buffer instance.
*
* This function creates a new string buffer. On error, @c NULL is
* returned and Eina error is set to #EINA_ERROR_OUT_OF_MEMORY. To
* free the resources, use eina_strbuf_common_free().
*
* @see eina_strbuf_common_free()
* @see eina_strbuf_common_append()
* @see eina_strbuf_common_string_get()
*/
Eina_Strbuf *eina_strbuf_common_new(size_t csize)
{
Eina_Strbuf *buf;
eina_error_set(0);
buf = malloc(sizeof(Eina_Strbuf));
if (EINA_UNLIKELY(!buf)) {
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
if (EINA_UNLIKELY(!_eina_strbuf_common_init(csize, buf))) {
eina_strbuf_common_free(buf);
return NULL;
}
return buf;
}
/*
* Constructor for the Eupnp_HTTP_Request structure
*
* Receives pointers to starting points and lengths of the method, uri
* and http version attributes and constructs the object. Also initializes the
* headers array. For dealing with headers, refer to the
* eupnp_http_request_header_* functions.
*
* @param method starting point of the method
* @param method_len method length
* @param uri starting point of the uri
* @param uri_len uri length
* @param httpver starting point of the http version
* @param httpver_len http version length
*
* @return Eupnp_HTTP_Request instance
*/
Eupnp_HTTP_Request *
eupnp_http_request_new(const char *method, int method_len, const char *uri, int uri_len, const char *httpver, int httpver_len)
{
Eupnp_HTTP_Request *h;
h = calloc(1, sizeof(Eupnp_HTTP_Request));
if (!h)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
ERROR("Could not create HTTP message.\n");
return NULL;
}
h->headers = eina_array_new(10);
if (!h->headers)
{
ERROR("Could not allocate memory for HTTP headers table.\n");
free(h);
return NULL;
}
h->method = eina_stringshare_add_length(method, method_len);
if (!h->method)
{
ERROR("Could not stringshare HTTP request method.\n");
eina_array_free(h->headers);
free(h);
return NULL;
}
h->http_version = eina_stringshare_add_length(httpver, httpver_len);
if (!h->http_version)
{
ERROR("Could not stringshare HTTP request version.\n");
eina_array_free(h->headers);
eina_stringshare_del(h->method);
free(h);
return NULL;
}
h->uri = eina_stringshare_add_length(uri, uri_len);
if (!h->uri)
{
ERROR("Could not stringshare HTTP request URI.\n");
eina_array_free(h->headers);
eina_stringshare_del(h->method);
eina_stringshare_del(h->http_version);
free(h);
return NULL;
}
return h;
}
/**
* @internal
*
* resize the buffer
* @param buf the buffer to resize
* @param size the minimum size of the buffer
*
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
*/
static inline Eina_Bool
_eina_strbuf_common_resize(size_t csize, Eina_Strbuf * buf, size_t size)
{
size_t new_size, new_step, delta;
void *buffer;
size += 1; // Add extra space for '\0'
if (size == buf->size)
/* nothing to do */
return EINA_TRUE;
else if (size > buf->size)
delta = size - buf->size;
else
delta = buf->size - size;
/* check if should keep the same step (just used while growing) */
if ((delta <= buf->step) && (size > buf->size))
new_step = buf->step;
else {
new_step = (((delta / EINA_STRBUF_INIT_STEP) + 1)
* EINA_STRBUF_INIT_STEP);
if (new_step > EINA_STRBUF_MAX_STEP)
new_step = EINA_STRBUF_MAX_STEP;
}
new_size = (((size / new_step) + 1) * new_step);
/* reallocate the buffer to the new size */
buffer = realloc(buf->buf, new_size * csize);
if (EINA_UNLIKELY(!buffer)) {
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return EINA_FALSE;
}
buf->buf = buffer;
buf->size = new_size;
buf->step = new_step;
eina_error_set(0);
return EINA_TRUE;
}
EAPI Eina_Bool
eupnp_service_parse_buffer(const char *buffer, int buffer_len, Eupnp_Service_Proxy *s)
{
Eina_Bool ret = EINA_FALSE;
if ((!buffer) || (!buffer_len) || (!s)) return ret;
Eupnp_Service_Parser *parser;
if (!s->xml_parser)
{
/* Creates the parser, which parses the first chunk */
DBG("Creating service parser.");
s->xml_parser = eupnp_service_parser_new(buffer, buffer_len, s);
if (!s->xml_parser)
{
ERR("Failed to parse first chunk");
goto parse_ret;
}
ret = EINA_TRUE;
goto parse_ret;
}
parser = s->xml_parser;
if (!parser->ctx)
{
// first_chunk_len < 4 case
eina_error_set(EUPNP_ERROR_SERVICE_PARSER_INSUFFICIENT_FEED);
return EINA_FALSE;
}
// Progressive feeds
if (parser->state.state == FINISH)
{
WRN("Already finished parsing");
ret = EINA_TRUE;
goto parse_ret;
}
DBG("Parsing XML (%d) at %p", buffer_len, buffer);
if (!xmlParseChunk(parser->ctx, buffer, buffer_len, 0))
{
ret = EINA_TRUE;
goto parse_ret;
}
parse_ret:
eupnp_service_parse_check_finished(s);
return ret;
}
EAPI void
eina_magic_fail(void *d,
Eina_Magic m,
Eina_Magic req_m,
const char *file,
const char *fnc,
int line)
{
eina_error_set(EINA_ERROR_MAGIC_FAILED);
if (!d)
eina_log_print(EINA_LOG_DOMAIN_GLOBAL, EINA_LOG_LEVEL_CRITICAL,
file, fnc, line,
"*** Eina Magic Check Failed !!!\n"
" Input handle pointer is NULL !\n"
"*** NAUGHTY PROGRAMMER!!!\n"
"*** SPANK SPANK SPANK!!!\n"
"*** Now go fix your code. Tut tut tut!\n"
"\n");
else
if (m == EINA_MAGIC_NONE)
eina_log_print(EINA_LOG_DOMAIN_GLOBAL, EINA_LOG_LEVEL_CRITICAL,
file, fnc, line,
"*** Eina Magic Check Failed !!!\n"
" Input handle has already been freed!\n"
"*** NAUGHTY PROGRAMMER!!!\n"
"*** SPANK SPANK SPANK!!!\n"
"*** Now go fix your code. Tut tut tut!\n"
"\n");
else
if (m != req_m)
eina_log_print(EINA_LOG_DOMAIN_GLOBAL, EINA_LOG_LEVEL_CRITICAL,
file, fnc, line,
"*** Eina Magic Check Failed !!!\n"
" Input handle is wrong type\n"
" Expected: %08x - %s\n"
" Supplied: %08x - %s\n"
"*** NAUGHTY PROGRAMMER!!!\n"
"*** SPANK SPANK SPANK!!!\n"
"*** Now go fix your code. Tut tut tut!\n"
"\n",
req_m, eina_magic_string_get(req_m),
m, eina_magic_string_get(m));
else
eina_log_print(EINA_LOG_DOMAIN_GLOBAL, EINA_LOG_LEVEL_CRITICAL,
file, fnc, line,
"*** Eina Magic Check Failed !!!\n"
" Why did you call me !\n"
"*** NAUGHTY PROGRAMMER!!!\n"
"*** SPANK SPANK SPANK!!!\n"
"*** Now go fix your code. Tut tut tut!\n"
"\n");
}
EAPI Eina_Array *
eina_array_new(unsigned int step)
{
Eina_Array *array;
eina_error_set(0);
array = malloc(sizeof (Eina_Array));
if (!array)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(array, EINA_MAGIC_ARRAY);
array->version = EINA_ARRAY_VERSION;
array->data = NULL;
array->total = 0;
array->count = 0;
array->step = step;
return array;
}
/* used from eina_inline_array.x, thus a needed symbol */
EAPI Eina_Bool
eina_array_grow(Eina_Array *array)
{
void **tmp;
unsigned int total;
EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE);
EINA_MAGIC_CHECK_ARRAY(array);
total = array->total + array->step;
eina_error_set(0);
tmp = realloc(array->data, sizeof (void *) * total);
if (EINA_UNLIKELY(!tmp))
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return 0;
}
array->total = total;
array->data = tmp;
return 1;
}
static Eina_Bool
_eina_stringshare_small_bucket_resize(Eina_Stringshare_Small_Bucket *bucket,
int size)
{
void *tmp;
tmp = realloc((void *)bucket->strings, size * sizeof(bucket->strings[0]));
if (!tmp)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return 0;
}
bucket->strings = tmp;
tmp = realloc(bucket->lengths, size * sizeof(bucket->lengths[0]));
if (!tmp)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return 0;
}
bucket->lengths = tmp;
tmp = realloc(bucket->references, size * sizeof(bucket->references[0]));
if (!tmp)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return 0;
}
bucket->references = tmp;
bucket->size = size;
return 1;
}
/*
* Constructor for the Eupnp_HTTP_Response structure
*
* Receives pointers to starting points and lengths of the http version, status
* code and http version attributes and constructs the object. Also initializes
* the headers array. For dealing with headers, refer to the
* eupnp_http_response_header_* functions.
*
* @param httpver starting point of the http version
* @param httpver_len http version length
* @param status_code starting point of the status code
* @param status_len status length
* @param reason_phrase starting point of the reason phrase
* @param reason_phrase_len reason phrase length
*
* @return Eupnp_HTTP_Response instance
*/
Eupnp_HTTP_Response *
eupnp_http_response_new(const char *httpver, int httpver_len, const char *status_code, int status_code_len, const char *reason_phrase, int reason_phrase_len)
{
Eupnp_HTTP_Response *r;
r = calloc(1, sizeof(Eupnp_HTTP_Response));
if (!r)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
ERROR("Could not create HTTP response.\n");
return NULL;
}
r->headers = eina_array_new(10);
if (!r->headers)
{
ERROR("Could not allocate memory for HTTP headers.\n");
free(r);
return NULL;
}
r->http_version = eina_stringshare_add_length(httpver, httpver_len);
if (!r->http_version)
{
ERROR("Could not stringshare http response version.\n");
eina_array_free(r->headers);
free(r);
return NULL;
}
r->status_code = strtol(status_code, NULL, 10);
r->reason_phrase = eina_stringshare_add_length(reason_phrase,
reason_phrase_len);
if (!r->reason_phrase)
{
ERROR("Could not stringshare http response phrase.\n");
eina_array_free(r->headers);
eina_stringshare_del(r->http_version);
free(r);
return NULL;
}
return r;
}
/*
* Adds a header to a response
*
* Adds a header to the response object given pointers to the key
* and value starting points and respective string lengths.
*
* @param m request to add the header into
* @param key starting point for the key
* @param key_len key length
* @param value starting point for the value
* @param value_len value length
*
* @note This function does not check duplicate headers. If added twice,
* header will be duplicated.
*
* @return On success returns EINA_TRUE, otherwise EINA_FALSE.
*/
Eina_Bool
eupnp_http_response_header_add(Eupnp_HTTP_Response *r, const char *key, int key_len, const char *value, int value_len)
{
Eupnp_HTTP_Header *h;
h = eupnp_http_header_new(key, key_len, value, value_len);
if (!h)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
ERROR("header alloc error.\n");
return EINA_FALSE;
}
if (!eina_array_push(r->headers, h))
{
WARN("incomplete headers\n");
eupnp_http_header_free(h);
return EINA_FALSE;
}
return EINA_TRUE;
}
/**
* Remove node from list.
*
* @note this code is meant to be fast: appends are O(1) and do not
* walk @a list.
*
* @note @a item is considered to be inside @a list, no checks are
* done to confirm that and giving nodes from different lists
* will lead to problems, especially if @a item is the head since
* it will be different from @a list and the wrong new head will
* be returned.
*
* @param list existing list head, must not be NULL.
* @param item existing list node, must not be NULL.
*
* @return the new list head. Use it and not @a list anymore.
*/
EAPI Eina_Inlist *
eina_inlist_remove(Eina_Inlist *list, Eina_Inlist *item)
{
Eina_Inlist *return_l;
/* checkme */
EINA_SAFETY_ON_NULL_RETURN_VAL(list, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(item, list);
if (EINA_UNLIKELY((item != list) && (!item->prev) && (!item->next)))
{
eina_error_set(EINA_ERROR_SAFETY_FAILED);
EINA_LOG_ERR("safety check failed: item %p does not appear to be part of an inlist!", item);
return list;
}
if (item->next)
item->next->prev = item->prev;
if (item->prev)
{
item->prev->next = item->next;
return_l = list;
}
else
{
return_l = item->next;
if (return_l)
return_l->last = list->last;
}
if (item == list->last)
list->last = item->prev;
item->next = NULL;
item->prev = NULL;
return return_l;
}
/**
* Creates a new iterator over existing matrix cells.
*
* This is a cheap walk, it will just report existing cells and holes
* in the sparse matrix will be ignored. That means the reported
* indexes will not be sequential.
*
* The iterator data will be the cell reference, one may query current
* position with eina_matrixsparse_cell_position_get() and cell value
* with eina_matrixsparse_cell_data_get().
*
* @param m The Sparse Matrix reference, must @b not be @c NULL.
* @return A new iterator.
*
* @warning if the matrix structure changes then the iterator becomes
* invalid! That is, if you add or remove cells this iterator
* behavior is undefined and your program may crash!
*/
EAPI Eina_Iterator *
eina_matrixsparse_iterator_new(const Eina_Matrixsparse *m)
{
Eina_Matrixsparse_Iterator *it;
it = calloc(1, sizeof(*it));
if (!it)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_MATRIXSPARSE_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->m = m;
it->ref.row = m->rows;
it->ref.col = m->rows ? m->rows->cols : NULL;
it->iterator.next = FUNC_ITERATOR_NEXT(_eina_matrixsparse_iterator_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_eina_matrixsparse_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(_eina_matrixsparse_iterator_free);
return &it->iterator;
}
/**
* Creates a new iterator over all matrix cells.
*
* Unlike eina_matrixsparse_iterator_new() this one will report all
* matrix cells, even those that are still empty (holes). These will
* be reported as dummy cells that contains no data.
*
* Be aware that iterating a big matrix (1000x1000) will call your
* function that number of times (1000000 times in that case) even if
* your matrix have no elements at all!
*
* The iterator data will be the cell reference, one may query current
* position with eina_matrixsparse_cell_position_get() and cell value
* with eina_matrixsparse_cell_data_get(). If cell is empty then the
* reference will be a dummy/placeholder, thus setting value with
* eina_matrixsparse_cell_data_set() will leave pointer unreferenced.
*
* @param m The Sparse Matrix reference, must @b not be @c NULL.
* @return A new iterator.
*
* @warning if the matrix structure changes then the iterator becomes
* invalid! That is, if you add or remove cells this iterator
* behavior is undefined and your program may crash!
*/
EAPI Eina_Iterator *
eina_matrixsparse_iterator_complete_new(const Eina_Matrixsparse *m)
{
Eina_Matrixsparse_Iterator_Complete *it;
it = calloc(1, sizeof(*it));
if (!it)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_MATRIXSPARSE_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->m = m;
it->idx.row = 0;
it->idx.col = 0;
it->ref.row = m->rows;
it->ref.col = m->rows ? m->rows->cols : NULL;
it->dummy.row.next = it->dummy.row.prev = NULL;
it->dummy.row.cols = it->dummy.row.last_col = it->dummy.row.last_used = NULL;
it->dummy.row.parent = (Eina_Matrixsparse *)m;
EINA_MAGIC_SET(&it->dummy.row, EINA_MAGIC_MATRIXSPARSE_ROW);
it->dummy.col.next = it->dummy.col.prev = NULL;
it->dummy.col.data = NULL;
it->dummy.col.parent = &it->dummy.row;
EINA_MAGIC_SET(&it->dummy.col, EINA_MAGIC_MATRIXSPARSE_CELL);
it->iterator.next = FUNC_ITERATOR_NEXT(_eina_matrixsparse_iterator_complete_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_eina_matrixsparse_iterator_complete_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(_eina_matrixsparse_iterator_complete_free);
return &it->iterator;
}
int
main(int argc, const char *argv[])
{
Eina_Hash *phone_book = NULL;
int i;
int64_t entry_id = 4;
char *phone = NULL;
Eina_Bool r;
Eina_Iterator *it;
void *data;
eina_init();
phone_book = eina_hash_int64_new(_phone_entry_free_cb);
// Add initial entries to our hash
for (i = 0; _start_entries[i].id != -1; i++)
{
eina_hash_add(phone_book, &_start_entries[i].id,
strdup(_start_entries[i].number));
}
// Look for a specific entry and get its phone number
phone = eina_hash_find(phone_book, &entry_id);
if (phone)
{
printf("Printing entry.\n");
printf("Id: %lld\n", entry_id);
printf("Number: %s\n\n", phone);
}
// Delete this entry
r = eina_hash_del(phone_book, &entry_id, NULL);
printf("Hash entry successfully deleted? %d\n\n", r);
// Modify the pointer data of an entry and free the old one
int64_t id3 = 3;
phone = eina_hash_modify(phone_book, &id3,
strdup("+23 45 111-11111"));
free(phone);
// Modify or add an entry to the hash with eina_hash_set
// Let's first add a new entry
int64_t id5 = 5;
eina_error_set(0);
phone = eina_hash_set(phone_book, &id5,
strdup("+55 01 234-56789"));
if (!phone)
{
Eina_Error err = eina_error_get();
if (!err)
{
printf("No previous phone found for id5. ");
printf("Creating new entry.\n");
}
else
printf("Error when setting phone for Raul Seixas\n");
}
else
{
printf("Old phone for id5 was %s\n", phone);
free(phone);
}
printf("\n");
// Now change the phone number
eina_error_set(0);
phone = eina_hash_set(phone_book, &id5,
strdup("+55 02 222-22222"));
if (phone)
{
printf("Changing phone for id5 to +55 02 222-22222. ");
printf("Old phone was %s\n", phone);
free(phone);
}
else
{
Eina_Error err = eina_error_get();
if (err)
printf("Error when changing phone for id5\n");
else
{
printf("No previous phone found for id5. ");
printf("Creating new entry.\n");
}
}
// There are many ways to iterate over our Phone book.
// First, iterate showing the names and associated numbers.
printf("List of phones:\n");
eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
printf("\n");
// Now iterate using an iterator
printf("List of phones:\n");
it = eina_hash_iterator_tuple_new(phone_book);
while (eina_iterator_next(it, &data))
{
Eina_Hash_Tuple *t = data;
const int64_t *id = t->key;
const char *number = t->data;
printf("%lld: %s\n", *id, number);
}
eina_iterator_free(it); // Always free the iterator after its use
printf("\n");
// Just iterate over the keys (names)
printf("List of ids in the phone book:\n");
it = eina_hash_iterator_key_new(phone_book);
while (eina_iterator_next(it, &data))
{
const int64_t *id = data;
printf("%lld\n", *id);
}
eina_iterator_free(it);
printf("\n");
// Just iterate over the data (numbers)
printf("List of numbers in the phone book:\n");
it = eina_hash_iterator_data_new(phone_book);
while (eina_iterator_next(it, &data))
{
const char *number = data;
printf("%s\n", number);
}
eina_iterator_free(it);
printf("\n");
// Check how many items are in the phone book
printf("There are %d items in the hash.\n\n",
eina_hash_population(phone_book));
// Change the name (key) on an entry
int64_t id6 = 6;
eina_hash_move(phone_book, &id5, &id6);
printf("List of phones after change:\n");
eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL);
printf("\n");
// Empty the phone book, but don't destroy it
eina_hash_free_buckets(phone_book);
printf("There are %d items in the hash.\n\n",
eina_hash_population(phone_book));
// Phone book could still be used, but we are freeing it since we are
// done for now
eina_hash_free(phone_book);
eina_shutdown();
}
