parent
4391aa6f08
commit
e9ddcdd311
|
@ -37,15 +37,9 @@
|
|||
typedef unsigned char Evas_Bool;
|
||||
|
||||
#define Evas_List Eina_List
|
||||
#define Evas_Hash Eina_Hash
|
||||
|
||||
typedef struct _Evas_Array_Hash Evas_Array_Hash;
|
||||
typedef struct _Evas_Hash Evas_Hash; /**< A Hash table handle */
|
||||
|
||||
struct _Evas_Hash
|
||||
{
|
||||
int population;
|
||||
Eina_Inlist *buckets[256];
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
@ -71,16 +65,48 @@ extern "C" {
|
|||
*
|
||||
* do we really need this? hmmm - let me think... there may be a better way
|
||||
*/
|
||||
EAPI Evas_Hash *evas_hash_add (Evas_Hash *hash, const char *key, const void *data);
|
||||
EAPI Evas_Hash *evas_hash_direct_add (Evas_Hash *hash, const char *key, const void *data);
|
||||
EAPI Evas_Hash *evas_hash_del (Evas_Hash *hash, const char *key, const void *data);
|
||||
EAPI void *evas_hash_find (const Evas_Hash *hash, const char *key);
|
||||
EAPI void *evas_hash_modify (Evas_Hash *hash, const char *key, const void *data);
|
||||
EAPI int evas_hash_size (const Evas_Hash *hash);
|
||||
EAPI void evas_hash_free (Evas_Hash *hash);
|
||||
EAPI void evas_hash_foreach (const Evas_Hash *hash, Evas_Bool (*func) (const Evas_Hash *hash, const char *key, void *data, void *fdata), const void *fdata);
|
||||
EAPI int evas_hash_alloc_error (void);
|
||||
static inline Eina_Hash *evas_hash_add(Eina_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
if (!hash) hash = eina_hash_string_superfast_new(NULL);
|
||||
if (!hash) return NULL;
|
||||
|
||||
eina_hash_add(hash, key, data);
|
||||
return hash;
|
||||
}
|
||||
|
||||
static inline Eina_Hash *evas_hash_direct_add(Eina_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
if (!hash) hash = eina_hash_string_superfast_new(NULL);
|
||||
if (!hash) return NULL;
|
||||
|
||||
eina_hash_direct_add(hash, key, data);
|
||||
return hash;
|
||||
}
|
||||
|
||||
static inline Eina_Hash *evas_hash_del(Eina_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
if (!hash) return NULL;
|
||||
eina_hash_del(hash, key, data);
|
||||
|
||||
if (eina_hash_population(hash) == 0)
|
||||
{
|
||||
eina_hash_free(hash);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return hash;
|
||||
}
|
||||
static inline int evas_hash_size(const Eina_Hash *hash)
|
||||
{
|
||||
if (!hash) return 0;
|
||||
return 255;
|
||||
}
|
||||
|
||||
#define evas_hash_find eina_hash_find
|
||||
#define evas_hash_modify eina_hash_modify
|
||||
#define evas_hash_free eina_hash_free
|
||||
#define evas_hash_foreach eina_hash_foreach
|
||||
#define evas_hash_alloc_error eina_error_get
|
||||
|
||||
/*
|
||||
* Evas List functions
|
||||
|
|
|
@ -11,7 +11,6 @@ AM_CPPFLAGS = -I. \
|
|||
|
||||
noinst_LTLIBRARIES = libevas_data.la
|
||||
libevas_data_la_SOURCES = \
|
||||
evas_hash.c \
|
||||
evas_array_hash.c \
|
||||
evas_mempool.c
|
||||
|
||||
|
|
|
@ -1,474 +0,0 @@
|
|||
/*
|
||||
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "Evas_Data.h"
|
||||
|
||||
typedef struct _Evas_Hash_El Evas_Hash_El;
|
||||
|
||||
struct _Evas_Hash_El
|
||||
{
|
||||
EINA_INLIST;
|
||||
const char *key;
|
||||
void *data;
|
||||
};
|
||||
|
||||
static inline int _evas_hash_gen(const char *key);
|
||||
|
||||
static int _evas_hash_alloc_error = 0;
|
||||
|
||||
static inline int
|
||||
_evas_hash_gen(const char *key)
|
||||
{
|
||||
unsigned int hash_num = 5381;
|
||||
const unsigned char *ptr;
|
||||
|
||||
if (!key) return 0;
|
||||
for (ptr = (unsigned char *)key; *ptr; ptr++)
|
||||
hash_num = (hash_num * 33) ^ *ptr;
|
||||
|
||||
hash_num &= 0xff;
|
||||
return (int)hash_num;
|
||||
}
|
||||
|
||||
/**
|
||||
* @defgroup Evas_Hash_Data Hash Data Functions
|
||||
*
|
||||
* Functions that add, access or remove data from hashes.
|
||||
*
|
||||
* The following example shows how to add and then access data in a
|
||||
* hash table:
|
||||
* @code
|
||||
* Evas_Hash *hash = NULL;
|
||||
* extern void *my_data;
|
||||
*
|
||||
* hash = evas_hash_add(hash, "My Data", my_data);
|
||||
* if (evas_hash_alloc_error())
|
||||
* {
|
||||
* fprintf(stderr, "ERROR: Memory is low. Hash allocation failed.\n");
|
||||
* exit(-1);
|
||||
* }
|
||||
* if (evas_hash_find(hash, "My Data") == my_data)
|
||||
* {
|
||||
* printf("My Data inserted and successfully found.\n");
|
||||
* }
|
||||
* @endcode
|
||||
*
|
||||
* What follows is another example, showing how the @ref evas_hash_del
|
||||
* function is used:
|
||||
* @code
|
||||
* extern Evas_Hash *hash;
|
||||
* extern void *data;
|
||||
*
|
||||
* printf("Insert some data...\n");
|
||||
* hash = evas_hash_add(hash, "My Data", my_data);
|
||||
* printf("Removing by key...\n");
|
||||
* hash = evas_hash_del(hash, "My Data", NULL);
|
||||
* printf("Insert some more data as a NULL key...\n");
|
||||
* hash = evas_hash_add(hash, NULL, my_data);
|
||||
* printf("Removing by data as a NULL key...\n");
|
||||
* hash = evas_hash_del(hash, NULL, my_data);
|
||||
* @endcode
|
||||
*/
|
||||
|
||||
/**
|
||||
* Adds an entry to the given hash table.
|
||||
*
|
||||
* @p key is expected to be a unique string within the hash table.
|
||||
* Otherwise, you cannot be sure which inserted data pointer will be
|
||||
* accessed with @ref evas_hash_find , and removed with
|
||||
* @ref evas_hash_del .
|
||||
*
|
||||
* Key strings are case sensitive.
|
||||
*
|
||||
* @ref evas_hash_alloc_error should be used to determine if an
|
||||
* allocation error occurred during this function.
|
||||
*
|
||||
* @param hash The given hash table. Can be @c NULL, in which case a
|
||||
* new hash table is allocated and returned.
|
||||
* @param key A unique string. Can be @c NULL.
|
||||
* @param data Data to associate with the string given by @p key.
|
||||
* @return Either the given hash table, or if the given value for @p
|
||||
* hash is @c NULL, then a new one. @c NULL will be returned
|
||||
* if memory could not be allocated for a new table.
|
||||
* @ingroup Evas_Hash_Data
|
||||
*/
|
||||
EAPI Evas_Hash *
|
||||
evas_hash_add(Evas_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
int hash_num;
|
||||
Evas_Hash_El *el;
|
||||
|
||||
if ((!key) || (!data)) return hash;
|
||||
_evas_hash_alloc_error = 0;
|
||||
if (!hash)
|
||||
{
|
||||
hash = calloc(1, sizeof(struct _Evas_Hash));
|
||||
if (!hash)
|
||||
{
|
||||
_evas_hash_alloc_error = 1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (!(el = malloc(sizeof(struct _Evas_Hash_El) + strlen(key) + 1)))
|
||||
{
|
||||
if (hash->population <= 0)
|
||||
{
|
||||
free(hash);
|
||||
hash = NULL;
|
||||
}
|
||||
_evas_hash_alloc_error = 1;
|
||||
return hash;
|
||||
};
|
||||
el->key = ((char *)el) + sizeof(struct _Evas_Hash_El);
|
||||
strcpy((char *) el->key, key);
|
||||
el->data = (void *)data;
|
||||
hash_num = _evas_hash_gen(key);
|
||||
hash->buckets[hash_num] = eina_inlist_prepend(hash->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
hash->population++;
|
||||
return hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds an entry to the given hash table and does not duplicate the string key.
|
||||
*
|
||||
* @p key is expected to be a unique string within the hash table.
|
||||
* Otherwise, you cannot be sure which inserted data pointer will be
|
||||
* accessed with @ref evas_hash_find , and removed with
|
||||
* @ref evas_hash_del . This call does not make a copy of the key so it must
|
||||
* be a string constant or stored elsewhere (in the object being added) etc.
|
||||
*
|
||||
* Key strings are case sensitive.
|
||||
*
|
||||
* @ref evas_hash_alloc_error should be used to determine if an
|
||||
* allocation error occurred during this function.
|
||||
*
|
||||
* @param hash The given hash table. Can be @c NULL, in which case a
|
||||
* new hash table is allocated and returned.
|
||||
* @param key A unique string. Can be @c NULL.
|
||||
* @param data Data to associate with the string given by @p key.
|
||||
* @return Either the given hash table, or if the given value for @p
|
||||
* hash is @c NULL, then a new one. @c NULL will be returned
|
||||
* if memory could not be allocated for a new table.
|
||||
* @ingroup Evas_Hash_Data
|
||||
*/
|
||||
EAPI Evas_Hash *
|
||||
evas_hash_direct_add(Evas_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
int hash_num;
|
||||
Evas_Hash_El *el;
|
||||
|
||||
if ((!key) || (!data)) return hash;
|
||||
_evas_hash_alloc_error = 0;
|
||||
if (!hash)
|
||||
{
|
||||
hash = calloc(1, sizeof(struct _Evas_Hash));
|
||||
if (!hash)
|
||||
{
|
||||
_evas_hash_alloc_error = 1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (!(el = malloc(sizeof(struct _Evas_Hash_El))))
|
||||
{
|
||||
if (hash->population <= 0)
|
||||
{
|
||||
free(hash);
|
||||
hash = NULL;
|
||||
}
|
||||
_evas_hash_alloc_error = 1;
|
||||
return hash;
|
||||
};
|
||||
el->key = key;
|
||||
el->data = (void *)data;
|
||||
hash_num = _evas_hash_gen(key);
|
||||
hash->buckets[hash_num] = eina_inlist_prepend(hash->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
hash->population++;
|
||||
return hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the entry identified by @p key or @p data from the given
|
||||
* hash table.
|
||||
*
|
||||
* If @p key is @c NULL, then @p data is used to find a match to
|
||||
* remove.
|
||||
*
|
||||
* @param hash The given hash table.
|
||||
* @param key The key string. Can be @c NULL.
|
||||
* @param data The data pointer to remove if @p key is @c NULL.
|
||||
* Otherwise, not required and can be @c NULL.
|
||||
* @return The modified hash table. If there are no entries left, the
|
||||
* hash table will be freed and @c NULL will be returned.
|
||||
* @ingroup Evas_Hash_Data
|
||||
*/
|
||||
EAPI Evas_Hash *
|
||||
evas_hash_del(Evas_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
int hash_num;
|
||||
Evas_Hash_El *el;
|
||||
|
||||
if (!hash) return NULL;
|
||||
if (!key)
|
||||
{
|
||||
int hash_num;
|
||||
|
||||
for (hash_num = 0; hash_num < 256; hash_num++)
|
||||
{
|
||||
EINA_INLIST_ITER_NEXT(hash->buckets[hash_num], el)
|
||||
if (el->data == data)
|
||||
{
|
||||
hash->buckets[hash_num] = eina_inlist_remove(hash->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
free(el);
|
||||
hash->population--;
|
||||
if (hash->population <= 0)
|
||||
{
|
||||
free(hash);
|
||||
hash = NULL;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
hash_num = _evas_hash_gen(key);
|
||||
EINA_INLIST_ITER_NEXT(hash->buckets[hash_num], el)
|
||||
if (!strcmp(el->key, key))
|
||||
{
|
||||
if ((!data) || (el->data == data))
|
||||
{
|
||||
hash->buckets[hash_num] = eina_inlist_remove(hash->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
free(el);
|
||||
hash->population--;
|
||||
if (hash->population <= 0)
|
||||
{
|
||||
free(hash);
|
||||
hash = NULL;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
}
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves a specific entry in the given hash table.
|
||||
* @param hash The given hash table.
|
||||
* @param key The key string of the entry to find.
|
||||
* @return The data pointer for the stored entry, or @c NULL if not
|
||||
* found.
|
||||
* @ingroup Evas_Hash_Data
|
||||
*/
|
||||
EAPI void *
|
||||
evas_hash_find(const Evas_Hash *hash, const char *key)
|
||||
{
|
||||
int hash_num;
|
||||
Evas_Hash_El *el;
|
||||
|
||||
_evas_hash_alloc_error = 0;
|
||||
if ((!hash) || (!key)) return NULL;
|
||||
hash_num = _evas_hash_gen(key);
|
||||
EINA_INLIST_ITER_NEXT(hash->buckets[hash_num], el)
|
||||
if (!strcmp(el->key, key))
|
||||
{
|
||||
((Evas_Hash *)hash)->buckets[hash_num] = eina_inlist_promote(((Evas_Hash *)hash)->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
return el->data;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies the entry pointer at the specified key and returns the old entry
|
||||
* @param hash The given hash table.
|
||||
* @param key The key string of the entry to modify.
|
||||
* @param data The data to replace the old entry, if it exists.
|
||||
* @return The data pointer for the old stored entry, or @c NULL if not
|
||||
* found. If an existing entry is not found, nothing is added to the
|
||||
* hash.
|
||||
* @ingroup Evas_Hash_Data
|
||||
*/
|
||||
EAPI void *
|
||||
evas_hash_modify(Evas_Hash *hash, const char *key, const void *data)
|
||||
{
|
||||
int hash_num;
|
||||
Evas_Hash_El *el;
|
||||
|
||||
_evas_hash_alloc_error = 0;
|
||||
if (!hash) return NULL;
|
||||
hash_num = _evas_hash_gen(key);
|
||||
EINA_INLIST_ITER_NEXT(hash->buckets[hash_num], el)
|
||||
if ((key) && (!strcmp(el->key, key)))
|
||||
{
|
||||
void *old_data;
|
||||
|
||||
hash->buckets[hash_num] = eina_inlist_promote(hash->buckets[hash_num], EINA_INLIST_GET(el));
|
||||
|
||||
old_data = el->data;
|
||||
el->data = (void *) data;
|
||||
return old_data;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @defgroup Evas_Hash_General_Group Hash General Functions
|
||||
*
|
||||
* Miscellaneous functions that operate on hash objects.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Retrieves the number of buckets available in the given hash table.
|
||||
* @param hash The given hash table.
|
||||
* @return @c 256 if @p hash is not @c NULL. @c 0 otherwise.
|
||||
* @ingroup Evas_Hash_General_Group
|
||||
*/
|
||||
EAPI int
|
||||
evas_hash_size(const Evas_Hash *hash)
|
||||
{
|
||||
if (!hash) return 0;
|
||||
return 256;
|
||||
}
|
||||
|
||||
/**
|
||||
* @todo Complete polishing documentation for evas_hash.c. The
|
||||
* functions' docs may be grouped, but they need some simplification.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Free an entire hash table
|
||||
* @param hash The hash table to be freed
|
||||
*
|
||||
* This function frees up all the memory allocated to storing the specified
|
||||
* hash tale pointed to by @p hash. Any entries in the table that the program
|
||||
* has no more pointers for elsewhere may now be lost, so this should only be
|
||||
* called if the program has lready freed any allocated data in the hash table
|
||||
* or has the pointers for data in teh table stored elswehere as well.
|
||||
*
|
||||
* Example:
|
||||
* @code
|
||||
* extern Evas_Hash *hash;
|
||||
*
|
||||
* evas_hash_free(hash);
|
||||
* hash = NULL;
|
||||
* @endcode
|
||||
* @ingroup Evas_Hash_General_Group
|
||||
*/
|
||||
EAPI void
|
||||
evas_hash_free(Evas_Hash *hash)
|
||||
{
|
||||
int i, size;
|
||||
|
||||
if (!hash) return;
|
||||
size = evas_hash_size(hash);
|
||||
for (i = 0; i < size; i++)
|
||||
{
|
||||
while (hash->buckets[i])
|
||||
{
|
||||
Evas_Hash_El *el;
|
||||
|
||||
el = (Evas_Hash_El *)hash->buckets[i];
|
||||
hash->buckets[i] = eina_inlist_remove(hash->buckets[i], EINA_INLIST_GET(el));
|
||||
free(el);
|
||||
}
|
||||
}
|
||||
free(hash);
|
||||
}
|
||||
|
||||
/**
|
||||
* Call a function on every member stored in the hash table
|
||||
* @param hash The hash table whose members will be walked
|
||||
* @param func The function to call on each parameter
|
||||
* @param fdata The data pointer to pass to the function being called
|
||||
*
|
||||
* This function goes through every entry in the hash table @p hash and calls
|
||||
* the function @p func on each member. The function should NOT modify the
|
||||
* hash table contents if it returns 1. IF the hash table contents are
|
||||
* modified by this function or the function wishes to stop processing it must
|
||||
* return 0, otherwise return 1 to keep processing.
|
||||
*
|
||||
* Example:
|
||||
* @code
|
||||
* extern Evas_Hash *hash;
|
||||
*
|
||||
* Evas_Bool hash_fn(Evas_Hash *hash, const char *key, void *data, void *fdata)
|
||||
* {
|
||||
* printf("Func data: %s, Hash entry: %s / %p\n", fdata, key, data);
|
||||
* return 1;
|
||||
* }
|
||||
*
|
||||
* int main(int argc, char **argv)
|
||||
* {
|
||||
* char *hash_fn_data;
|
||||
*
|
||||
* hash_fn_data = strdup("Hello World");
|
||||
* evas_hash_foreach(hash, hash_fn, hash_fn_data);
|
||||
* free(hash_fn_data);
|
||||
* }
|
||||
* @endcode
|
||||
* @ingroup Evas_Hash_General_Group
|
||||
*/
|
||||
EAPI void
|
||||
evas_hash_foreach(const Evas_Hash *hash, Evas_Bool (*func) (const Evas_Hash *hash, const char *key, void *data, void *fdata), const void *fdata)
|
||||
{
|
||||
int i, size;
|
||||
|
||||
if (!hash) return;
|
||||
size = evas_hash_size(hash);
|
||||
for (i = 0; i < size; i++)
|
||||
{
|
||||
Eina_Inlist *l, *next_l;
|
||||
|
||||
for (l = hash->buckets[i]; l;)
|
||||
{
|
||||
Evas_Hash_El *el;
|
||||
|
||||
next_l = l->next;
|
||||
el = (Evas_Hash_El *)l;
|
||||
if (!func(hash, el->key, el->data, (void *)fdata)) return;
|
||||
l = next_l;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return memory allocation failure flag after an function requiring allocation
|
||||
* @return The state of the allocation flag
|
||||
*
|
||||
* This function returns the state of the memory allocation flag. This flag is
|
||||
* set if memory allocations fail during evas_hash_add() calls. If they do, 1
|
||||
* will be returned, otherwise 0 will be returned. The flag will remain in its
|
||||
* current state until the next call that requires allocation is called, and
|
||||
* is then reset.
|
||||
*
|
||||
* Example:
|
||||
* @code
|
||||
* Evas_Hash *hash = NULL;
|
||||
* extern void *my_data;
|
||||
*
|
||||
* hash = evas_hash_add(hash, "My Data", my_data);
|
||||
* if (evas_hash_alloc_error())
|
||||
* {
|
||||
* fprintf(stderr, "ERROR: Memory is low. Hash allocation failed.\n");
|
||||
* exit(-1);
|
||||
* }
|
||||
* if (evas_hash_find(hash, "My Data") == my_data)
|
||||
* {
|
||||
* printf("My Data inserted and successfully found.\n");
|
||||
* }
|
||||
* @endcode
|
||||
* @ingroup Evas_Hash_General_Group
|
||||
*/
|
||||
EAPI int
|
||||
evas_hash_alloc_error(void)
|
||||
{
|
||||
return _evas_hash_alloc_error;
|
||||
}
|
|
@ -498,7 +498,7 @@ evas_common_font_int_modify_cache_by(RGBA_Font_Int *fi, int dir)
|
|||
{
|
||||
int sz_hash = 0;
|
||||
|
||||
if (fi->glyphs) sz_hash = sizeof(Evas_Hash);
|
||||
if (fi->glyphs) sz_hash = evas_hash_size(fi->glyphs);
|
||||
evas_hash_foreach(fi->glyphs, font_modify_cache_cb, &dir);
|
||||
font_cache_usage += dir * (sizeof(RGBA_Font) + sz_hash +
|
||||
sizeof(FT_FaceRec) + 16384); /* fudge values */
|
||||
|
|
Loading…
Reference in New Issue