diff options
Diffstat (limited to 'src/tests/Ecore_Data.h')
| -rw-r--r-- | src/tests/Ecore_Data.h | 557 |
1 files changed, 557 insertions, 0 deletions
diff --git a/src/tests/Ecore_Data.h b/src/tests/Ecore_Data.h new file mode 100644 index 0000000..50d42f1 --- /dev/null +++ b/src/tests/Ecore_Data.h @@ -0,0 +1,557 @@ +#ifndef _ECORE_DATA_H +# define _ECORE_DATA_H + +#include <stdio.h> +/* we need this for size_t */ +#include <stddef.h> + +#ifdef EAPI +# undef EAPI +#endif + +#ifdef _WIN32 +# ifdef EFL_ECORE_BUILD +# ifdef DLL_EXPORT +# define EAPI __declspec(dllexport) +# else +# define EAPI +# endif /* ! DLL_EXPORT */ +# else +# define EAPI __declspec(dllimport) +# endif /* ! EFL_ECORE_BUILD */ +#else +# ifdef __GNUC__ +# if __GNUC__ >= 4 +# define EAPI __attribute__ ((visibility("default"))) +# else +# define EAPI +# endif +# else +# define EAPI +# endif +#endif /* ! _WIN32 */ + +/** + * @file Ecore_Data.h + * @brief Contains threading, list, hash, debugging and tree functions. + */ + +# ifdef __cplusplus +extern "C" { +# endif + + +#ifndef TRUE +# define TRUE 1 +#endif + +#ifndef FALSE +# define FALSE 0 +#endif + +#ifdef FREE +# undef FREE +#endif +#define FREE(ptr) free(ptr); ptr = NULL; + +#ifdef IF_FREE +# undef IF_FREE +#endif +#define IF_FREE(ptr) if (ptr) {free(ptr); } ptr = NULL; + +/* convenience macros for checking pointer parameters for non-NULL */ +#undef CHECK_PARAM_POINTER_RETURN +#define CHECK_PARAM_POINTER_RETURN(sparam, param, ret) \ + if (!(param)) \ + { \ + printf("***** Developer Warning ***** :\n" \ + "\tThis program is calling:\n\n" \ + "\t%s();\n\n" \ + "\tWith the parameter:\n\n" \ + "\t%s\n\n" \ + "\tbeing NULL. Please fix your program.", __FUNCTION__, sparam); \ + if (getenv("ECORE_ERROR_ABORT")) { abort(); } \ + return ret; \ + } + +#undef CHECK_PARAM_POINTER +#define CHECK_PARAM_POINTER(sparam, param) \ + if (!(param)) \ + { \ + printf("***** Developer Warning ***** :\n" \ + "\tThis program is calling:\n\n" \ + "\t%s();\n\n" \ + "\tWith the parameter:\n\n" \ + "\t%s\n\n" \ + "\tbeing NULL. Please fix your program.", __FUNCTION__, sparam); \ + if (getenv("ECORE_ERROR_ABORT")) { abort(); } \ + return; \ + } + + +# ifdef __sgi +# define __FUNCTION__ "unknown" +# ifndef __cplusplus +# define inline +# endif +# endif + +# define ECORE_SORT_MIN 0 +# define ECORE_SORT_MAX 1 + +typedef void (*Ecore_For_Each)(void *value, void *user_data); +# define ECORE_FOR_EACH(function) ((Ecore_For_Each)function) + +typedef void (*Ecore_Free_Cb)(void *data); +# define ECORE_FREE_CB(func) ((Ecore_Free_Cb)func) + +typedef unsigned int (*Ecore_Hash_Cb)(const void *key); +# define ECORE_HASH_CB(function) ((Ecore_Hash_Cb)function) + +typedef int (*Ecore_Compare_Cb)(const void *data1, const void *data2); +# define ECORE_COMPARE_CB(function) ((Ecore_Compare_Cb)function) + +typedef struct _ecore_list Ecore_List; +# define ECORE_LIST(list) ((Ecore_List *)list) + +typedef struct _ecore_list_node Ecore_List_Node; +# define ECORE_LIST_NODE(node) ((Ecore_List_Node *)node) + +typedef struct _ecore_strbuf Ecore_Strbuf; +# define ECORE_STRBUF(buf) ((Ecore_Strbuf *)buf) + +struct _ecore_list_node +{ + void *data; + struct _ecore_list_node *next; +}; + +struct _ecore_list +{ + Ecore_List_Node *first; /* The first node in the list */ + Ecore_List_Node *last; /* The last node in the list */ + Ecore_List_Node *current; /* The current node in the list */ + + Ecore_Free_Cb free_func; /* The callback to free data in nodes */ + + int nodes; /* The number of nodes in the list */ + int index; /* The position from the front of the + list of current node */ +}; + +EAPI int ecore_direct_compare(const void *key1, const void *key2); +EAPI int ecore_str_compare(const void *key1, const void *key2); + +EAPI unsigned int ecore_direct_hash(const void *key); +EAPI unsigned int ecore_str_hash(const void *key); + +/* Creating and initializing new list structures */ +EAPI Ecore_List * ecore_list_new(void); +EAPI int ecore_list_init(Ecore_List *list); + +/* Adding items to the list */ +EAPI int ecore_list_append(Ecore_List *list, void *_data); +EAPI int ecore_list_prepend(Ecore_List *list, void *_data); +EAPI int ecore_list_insert(Ecore_List *list, void *_data); +EAPI int ecore_list_append_list(Ecore_List *list, + Ecore_List *append); +EAPI int ecore_list_prepend_list(Ecore_List *list, + Ecore_List *prepend); + +/* Removing items from the list */ +EAPI int ecore_list_remove_destroy(Ecore_List *list); +EAPI void * ecore_list_remove(Ecore_List *list); +EAPI void * ecore_list_first_remove(Ecore_List *list); +EAPI void * ecore_list_last_remove(Ecore_List *list); + +/* Retrieve the current position in the list */ +EAPI void * ecore_list_current(Ecore_List *list); +EAPI void * ecore_list_first(Ecore_List *list); +EAPI void * ecore_list_last(Ecore_List *list); +EAPI int ecore_list_index(Ecore_List *list); +EAPI int ecore_list_count(Ecore_List *list); + +/* Traversing the list */ +EAPI int ecore_list_for_each(Ecore_List *list, + Ecore_For_Each function, + void *user_data); +EAPI void * ecore_list_first_goto(Ecore_List *list); +EAPI void * ecore_list_last_goto(Ecore_List *list); +EAPI void * ecore_list_index_goto(Ecore_List *list, int index); +EAPI void * ecore_list_goto(Ecore_List *list, const void *_data); + +/* Traversing the list and returning data */ +EAPI void * ecore_list_next(Ecore_List *list); +EAPI void * ecore_list_find(Ecore_List *list, + Ecore_Compare_Cb function, + const void *user_data); + +/* Sorting the list */ +EAPI int ecore_list_sort(Ecore_List *list, + Ecore_Compare_Cb compare, + char order); +EAPI int ecore_list_mergesort(Ecore_List *list, + Ecore_Compare_Cb compare, + char order); +EAPI int ecore_list_heapsort(Ecore_List *list, + Ecore_Compare_Cb compare, + char order); +EAPI void ecore_list_merge(Ecore_List *list, Ecore_List *l2, + Ecore_Compare_Cb, char order); + +/* Check to see if there is any data in the list */ +EAPI int ecore_list_empty_is(Ecore_List *list); + +/* Remove every node in the list without freeing the list itself */ +EAPI int ecore_list_clear(Ecore_List *list); +/* Free the list and it's contents */ +EAPI void ecore_list_destroy(Ecore_List *list); + +/* Creating and initializing list nodes */ +EAPI Ecore_List_Node *ecore_list_node_new(void); +EAPI int ecore_list_node_init(Ecore_List_Node *newNode); + +/* Destroying nodes */ +EAPI int ecore_list_node_destroy(Ecore_List_Node *_e_node, + Ecore_Free_Cb free_func); + +EAPI int ecore_list_free_cb_set(Ecore_List *list, + Ecore_Free_Cb free_func); + +typedef Ecore_List Ecore_DList; +# define ECORE_DLIST(dlist) ((Ecore_DList *)dlist) + +typedef struct _ecore_dlist_node Ecore_DList_Node; +# define ECORE_DLIST_NODE(dlist) ((Ecore_DList_Node *)dlist) + +struct _ecore_dlist_node +{ + Ecore_List_Node single; + Ecore_DList_Node *previous; +}; + +/* Creating and initializing new list structures */ +EAPI Ecore_DList *ecore_dlist_new(void); +EAPI int ecore_dlist_init(Ecore_DList *list); +EAPI void ecore_dlist_destroy(Ecore_DList *list); + +/* Adding items to the list */ +EAPI int ecore_dlist_append(Ecore_DList *_e_dlist, void *_data); +EAPI int ecore_dlist_prepend(Ecore_DList *_e_dlist, void *_data); +EAPI int ecore_dlist_insert(Ecore_DList *_e_dlist, void *_data); +EAPI int ecore_dlist_append_list(Ecore_DList *_e_dlist, + Ecore_DList *append); +EAPI int ecore_dlist_prepend_list(Ecore_DList *_e_dlist, + Ecore_DList *prepend); + +/* Info about list's state */ +# define ecore_dlist_first(list) ecore_list_first(list) +# define ecore_dlist_last(list) ecore_list_last(list) +EAPI void * ecore_dlist_current(Ecore_DList *list); +EAPI int ecore_dlist_index(Ecore_DList *list); +# define ecore_dlist_count(list) ecore_list_count(list) + +/* Removing items from the list */ +EAPI void * ecore_dlist_remove(Ecore_DList *_e_dlist); +EAPI void * ecore_dlist_first_remove(Ecore_DList *_e_dlist); +EAPI int ecore_dlist_remove_destroy(Ecore_DList *list); +EAPI void * ecore_dlist_last_remove(Ecore_DList *_e_dlist); + +/* Traversing the list */ +# define ecore_dlist_for_each(list, function, user_data) \ + ecore_list_for_each(list, function, user_data) +EAPI void * ecore_dlist_first_goto(Ecore_DList *_e_dlist); +EAPI void * ecore_dlist_last_goto(Ecore_DList *_e_dlist); +EAPI void * ecore_dlist_index_goto(Ecore_DList *_e_dlist, int index); +EAPI void * ecore_dlist_goto(Ecore_DList *_e_dlist, void *_data); + +/* Traversing the list and returning data */ +EAPI void * ecore_dlist_next(Ecore_DList *list); +EAPI void * ecore_dlist_previous(Ecore_DList *list); + +/* Sorting the list */ +EAPI int ecore_dlist_sort(Ecore_DList *list, + Ecore_Compare_Cb compare, + char order); +EAPI int ecore_dlist_mergesort(Ecore_DList *list, + Ecore_Compare_Cb compare, + char order); +# define ecore_dlist_heapsort(list, compare, order) \ + ecore_list_heapsort(list, compare, order) +EAPI void ecore_dlist_merge(Ecore_DList *list, Ecore_DList *l2, + Ecore_Compare_Cb, char order); + +/* Check to see if there is any data in the list */ +EAPI int ecore_dlist_empty_is(Ecore_DList *_e_dlist); + +/* Remove every node in the list without free'ing it */ +EAPI int ecore_dlist_clear(Ecore_DList *_e_dlist); + +/* Creating and initializing list nodes */ +EAPI int ecore_dlist_node_init(Ecore_DList_Node *node); +EAPI Ecore_DList_Node *ecore_dlist_node_new(void); + +/* Destroying nodes */ +EAPI int ecore_dlist_node_destroy(Ecore_DList_Node *node, + Ecore_Free_Cb free_func); + +EAPI int ecore_dlist_free_cb_set(Ecore_DList *dlist, + Ecore_Free_Cb free_func); + + + +/* + * Hash Table Implementation: + * + * Traditional hash table implementation. I had tried a list of tables + * approach to save on the realloc's but it ended up being much slower than + * the traditional approach. + */ + +typedef struct _ecore_hash_node Ecore_Hash_Node; +# define ECORE_HASH_NODE(hash) ((Ecore_Hash_Node *)hash) + +struct _ecore_hash_node +{ + Ecore_Hash_Node *next; /* Pointer to the next node in the bucket list */ + void *key; /* The key for the data node */ + void *value; /* The value associated with this node */ +}; + +typedef struct _ecore_hash Ecore_Hash; +# define ECORE_HASH(hash) ((Ecore_Hash *)hash) + +struct _ecore_hash +{ + Ecore_Hash_Node **buckets; + int size; /* An index into the table of primes to + determine size */ + int nodes; /* The number of nodes currently in the hash */ + + int index; /* The current index into the bucket table */ + + Ecore_Compare_Cb compare; /* The function used to compare node values */ + Ecore_Hash_Cb hash_func; /* The callback function to determine hash */ + + Ecore_Free_Cb free_key; /* The callback function to free key */ + Ecore_Free_Cb free_value; /* The callback function to free value */ +}; + +/* Create and initialize a hash */ +EAPI Ecore_Hash *ecore_hash_new(Ecore_Hash_Cb hash_func, + Ecore_Compare_Cb compare); +EAPI int ecore_hash_init(Ecore_Hash *hash, + Ecore_Hash_Cb hash_func, + Ecore_Compare_Cb compare); + +/* Functions related to freeing the data in the hash table */ +EAPI int ecore_hash_free_key_cb_set(Ecore_Hash *hash, + Ecore_Free_Cb function); +EAPI int ecore_hash_free_value_cb_set(Ecore_Hash *hash, + Ecore_Free_Cb function); +EAPI void ecore_hash_destroy(Ecore_Hash *hash); + +EAPI int ecore_hash_count(Ecore_Hash *hash); +EAPI int ecore_hash_for_each_node(Ecore_Hash *hash, + Ecore_For_Each for_each_func, + void *user_data); +EAPI Ecore_List *ecore_hash_keys(Ecore_Hash *hash); + +/* Retrieve and store data into the hash */ +EAPI void * ecore_hash_get(Ecore_Hash *hash, const void *key); +EAPI int ecore_hash_set(Ecore_Hash *hash, void *key, void *value); +EAPI int ecore_hash_hash_set(Ecore_Hash *hash, Ecore_Hash *set); +EAPI void * ecore_hash_remove(Ecore_Hash *hash, const void *key); +EAPI void * ecore_hash_find(Ecore_Hash *hash, + Ecore_Compare_Cb compare, + const void *value); +EAPI void ecore_hash_dump_graph(Ecore_Hash *hash); +EAPI void ecore_hash_dump_stats(Ecore_Hash *hash); + + +typedef struct _ecore_heap Ecore_Sheap; +# define ECORE_HEAP(heap) ((Ecore_Sheap *)heap) + +struct _ecore_heap +{ + void **data; + int size; + int space; + + char order, sorted; + + /* Callback for comparing node values, default is direct comparison */ + Ecore_Compare_Cb compare; + + /* Callback for freeing node data, default is NULL */ + Ecore_Free_Cb free_func; +}; + +EAPI Ecore_Sheap *ecore_sheap_new(Ecore_Compare_Cb compare, int size); +EAPI void ecore_sheap_destroy(Ecore_Sheap *heap); +EAPI int ecore_sheap_init(Ecore_Sheap *heap, + Ecore_Compare_Cb compare, + int size); +EAPI int ecore_sheap_free_cb_set(Ecore_Sheap *heap, + Ecore_Free_Cb free_func); +EAPI int ecore_sheap_insert(Ecore_Sheap *heap, void *data); +EAPI void * ecore_sheap_extract(Ecore_Sheap *heap); +EAPI void * ecore_sheap_extreme(Ecore_Sheap *heap); +EAPI int ecore_sheap_change(Ecore_Sheap *heap, + void *item, + void *newval); +EAPI int ecore_sheap_compare_set(Ecore_Sheap *heap, + Ecore_Compare_Cb compare); +EAPI void ecore_sheap_order_set(Ecore_Sheap *heap, char order); +EAPI void ecore_sheap_sort(Ecore_Sheap *heap); + +EAPI void * ecore_sheap_item(Ecore_Sheap *heap, int i); + + +typedef struct _ecore_string Ecore_String; +struct _ecore_string +{ + char *string; + int references; +}; + +EAPI int ecore_string_init(); +EAPI void ecore_string_shutdown(); +EAPI const char *ecore_string_instance(const char *string); +EAPI void ecore_string_release(const char *string); + +typedef struct _Ecore_Tree_Node Ecore_Tree_Node; +# define ECORE_TREE_NODE(object) ((Ecore_Tree_Node *)object) +struct _Ecore_Tree_Node +{ + + /* The actual data for each node */ + void *key; + void *value; + + /* Pointers to surrounding nodes */ + Ecore_Tree_Node *parent; + Ecore_Tree_Node *left_child; + Ecore_Tree_Node *right_child; + + /* Book keeping information for quicker balancing of the tree */ + int max_right; + int max_left; +}; + +typedef struct _Ecore_Tree Ecore_Tree; +# define ECORE_TREE(object) ((Ecore_Tree *)object) +struct _Ecore_Tree +{ + /* Nodes of the tree */ + Ecore_Tree_Node *tree; + + /* Callback for comparing node values, default is direct comparison */ + Ecore_Compare_Cb compare_func; + + /* Callback for freeing node data, default is NULL */ + Ecore_Free_Cb free_value; + /* Callback for freeing node key, default is NULL */ + Ecore_Free_Cb free_key; +}; + +/* Some basic tree functions */ +/* Allocate and initialize a new tree */ +EAPI Ecore_Tree * ecore_tree_new(Ecore_Compare_Cb compare_func); +/* Initialize a new tree */ +EAPI int ecore_tree_init(Ecore_Tree *tree, + Ecore_Compare_Cb compare_func); + +/* Free the tree */ +EAPI int ecore_tree_destroy(Ecore_Tree *tree); +/* Check to see if the tree has any nodes in it */ +EAPI int ecore_tree_empty_is(Ecore_Tree *tree); + +/* Retrieve the value associated with key */ +EAPI void * ecore_tree_get(Ecore_Tree *tree, const void *key); +EAPI Ecore_Tree_Node *ecore_tree_get_node(Ecore_Tree *tree, const void *key); +/* Retrieve the value of node with key greater than or equal to key */ +EAPI void * ecore_tree_closest_larger_get(Ecore_Tree *tree, + const void *key); +/* Retrieve the value of node with key less than or equal to key */ +EAPI void * ecore_tree_closest_smaller_get(Ecore_Tree *tree, + const void *key); + +/* Set the value associated with key to value */ +EAPI int ecore_tree_set(Ecore_Tree *tree, void *key, void *value); +/* Remove the key from the tree */ +EAPI int ecore_tree_remove(Ecore_Tree *tree, const void *key); + +/* Add a node to the tree */ +EAPI int ecore_tree_node_add(Ecore_Tree *tree, + Ecore_Tree_Node *node); +/* Remove a node from the tree */ +EAPI int ecore_tree_node_remove(Ecore_Tree *tree, + Ecore_Tree_Node *node); + +/* For each node in the tree perform the for_each_func function */ +/* For this one pass in the node */ +EAPI int ecore_tree_for_each_node(Ecore_Tree *tree, + Ecore_For_Each for_each_func, + void *user_data); +/* And here pass in the node's value */ +EAPI int ecore_tree_for_each_node_value( + Ecore_Tree *tree, + Ecore_For_Each + for_each_func, + void *user_data); + +/* Some basic node functions */ +/* Initialize a node */ +EAPI int ecore_tree_node_init(Ecore_Tree_Node *new_node); +/* Allocate and initialize a new node */ +EAPI Ecore_Tree_Node *ecore_tree_node_new(void); +/* Free the desired node */ +EAPI int ecore_tree_node_destroy(Ecore_Tree_Node *node, + Ecore_Free_Cb free_value, + Ecore_Free_Cb free_key); + +/* Set the node's key to key */ +EAPI int ecore_tree_node_key_set(Ecore_Tree_Node *node, void *key); +/* Retrieve the key in node */ +EAPI void * ecore_tree_node_key_get(Ecore_Tree_Node *node); + +/* Set the node's value to value */ +EAPI int ecore_tree_node_value_set(Ecore_Tree_Node *node, + void *value); +/* Retrieve the value in node */ +EAPI void * ecore_tree_node_value_get(Ecore_Tree_Node *node); + +/* Add a function to free the data stored in nodes */ +EAPI int ecore_tree_free_value_cb_set(Ecore_Tree *tree, + Ecore_Free_Cb free_value); +/* Add a function to free the keys stored in nodes */ +EAPI int ecore_tree_free_key_cb_set(Ecore_Tree *tree, + Ecore_Free_Cb free_key); + + +EAPI Ecore_Strbuf * ecore_strbuf_new(void); +EAPI void ecore_strbuf_free(Ecore_Strbuf *buf); +EAPI void ecore_strbuf_append(Ecore_Strbuf *buf, const char *str); +EAPI void ecore_strbuf_append_char(Ecore_Strbuf *buf, char c); +EAPI void ecore_strbuf_insert(Ecore_Strbuf *buf, const char *str, + size_t pos); +# define ecore_strbuf_prepend(buf, str) ecore_strbuf_insert(buf, str, 0) +EAPI const char * ecore_strbuf_string_get(Ecore_Strbuf *buf); +EAPI size_t ecore_strbuf_length_get(Ecore_Strbuf *buf); +EAPI int ecore_strbuf_replace(Ecore_Strbuf *buf, const char *str, + const char *with, unsigned int n); +# define ecore_strbuf_replace_first(buf, str, with) \ + ecore_strbuf_replace(buf, str, with, 1) +EAPI int ecore_strbuf_replace_all(Ecore_Strbuf *buf, + const char *str, + const char *with); + +extern int ecore_str_compare(const void *key1, const void *key2); +extern int ecore_direct_compare(const void *key1, const void *key2); +extern unsigned int ecore_str_hash(const void *key); + +#ifdef __cplusplus +} +#endif +#endif /* _ECORE_DATA_H */ |