u_handle_table.c File Reference

Generic handle table implementation. More...

Include dependency graph for u_handle_table.c:

Go to the source code of this file.

Data Structures
struct	handle_table
Defines
#define	HANDLE_TABLE_INITIAL_SIZE   16
Functions
struct handle_table *	handle_table_create (void)
void	handle_table_set_destroy (struct handle_table *ht, void(*destroy)(void *object))
	Set an optional destructor callback.
static int	handle_table_resize (struct handle_table *ht, unsigned minimum_size)
	Resize the table if necessary.
static void	handle_table_clear (struct handle_table *ht, unsigned index)
unsigned	handle_table_add (struct handle_table *ht, void *object)
	Add a new object.
unsigned	handle_table_set (struct handle_table *ht, unsigned handle, void *object)
	Returns zero on failure (out of memory).
void *	handle_table_get (struct handle_table *ht, unsigned handle)
	Fetch an existing object.
void	handle_table_remove (struct handle_table *ht, unsigned handle)
unsigned	handle_table_get_next_handle (struct handle_table *ht, unsigned handle)
unsigned	handle_table_get_first_handle (struct handle_table *ht)
void	handle_table_destroy (struct handle_table *ht)

---

Detailed Description

Generic handle table implementation.

Author:

José Fonseca <jrfonseca@tungstengraphics.com>

Definition in file u_handle_table.c.

---

Define Documentation

#define HANDLE_TABLE_INITIAL_SIZE   16

Definition at line 43 of file u_handle_table.c.

---

Function Documentation

unsigned handle_table_add	(	struct handle_table *	ht,
		void *	object
	)

Add a new object.

Returns a zero handle on failure (out of memory).

Definition at line 150 of file u_handle_table.c.

References assert, handle_table::filled, handle_table_resize(), handle_table::objects, and handle_table::size.

{
   unsigned index;
   unsigned handle;
   
   assert(ht);
   assert(object);
   if(!object)
      return 0;

   /* linear search for an empty handle */
   while(ht->filled < ht->size) {
      if(!ht->objects[ht->filled])
         break;
      ++ht->filled;
   }
  
   index = ht->filled;
   handle = index + 1;
   
   /* check integer overflow */
   if(!handle)
      return 0;
   
   /* grow the table if necessary */
   if(!handle_table_resize(ht, index))
      return 0;

   assert(!ht->objects[index]);
   ht->objects[index] = object;
   ++ht->filled;
   
   return handle;
}

static void handle_table_clear	(	struct handle_table *	ht,
		unsigned	index
	)			[static]

Definition at line 128 of file u_handle_table.c.

References handle_table::destroy, and handle_table::objects.

{
   void *object;
   
   /* The order here is important so that the object being destroyed is not
    * present in the table when seen by the destroy callback, because the 
    * destroy callback may directly or indirectly call the other functions in 
    * this module.
    */

   object = ht->objects[index];
   if(object) {
      ht->objects[index] = NULL;
      
      if(ht->destroy)
         ht->destroy(object);
   }   
}

struct handle_table* handle_table_create

(

void

)

[read]

Definition at line 62 of file u_handle_table.c.

References CALLOC, handle_table::destroy, handle_table::filled, FREE, HANDLE_TABLE_INITIAL_SIZE, MALLOC_STRUCT, handle_table::objects, and handle_table::size.

{
   struct handle_table *ht;
   
   ht = MALLOC_STRUCT(handle_table);
   if(!ht)
      return NULL;
   
   ht->objects = (void **)CALLOC(HANDLE_TABLE_INITIAL_SIZE, sizeof(void *));
   if(!ht->objects) {
      FREE(ht);
      return NULL;
   }
   
   ht->size = HANDLE_TABLE_INITIAL_SIZE;
   ht->filled = 0;
   
   ht->destroy = NULL;
   
   return ht;
}

void handle_table_destroy

(

struct handle_table *

ht

)

Definition at line 281 of file u_handle_table.c.

References assert, handle_table::destroy, FREE, handle_table_clear(), handle_table::objects, and handle_table::size.

{
   unsigned index;
   assert(ht);

   if(ht->destroy)
      for(index = 0; index < ht->size; ++index)
         handle_table_clear(ht, index);
   
   FREE(ht->objects);
   FREE(ht);
}

void* handle_table_get	(	struct handle_table *	ht,
		unsigned	handle
	)

Fetch an existing object.

Returns NULL for an invalid handle.

Definition at line 218 of file u_handle_table.c.

References assert, handle_table::objects, and handle_table::size.

{
   void *object;
   
   assert(ht);
   assert(handle);
   if(!handle || handle > ht->size)
      return NULL;

   object = ht->objects[handle - 1];
   
   return object;
}

unsigned handle_table_get_first_handle

(

struct handle_table *

ht

)

Definition at line 274 of file u_handle_table.c.

References handle_table_get_next_handle().

{
   return handle_table_get_next_handle(ht, 0);
}

unsigned handle_table_get_next_handle	(	struct handle_table *	ht,
		unsigned	handle
	)

Definition at line 259 of file u_handle_table.c.

References handle_table::objects, and handle_table::size.

{
   unsigned index;
   
   for(index = handle; index < ht->size; ++index) {
      if(ht->objects[index])
         return index + 1;
   }

   return 0;
}

void handle_table_remove	(	struct handle_table *	ht,
		unsigned	handle
	)

Definition at line 235 of file u_handle_table.c.

References assert, handle_table::filled, handle_table_clear(), handle_table::objects, and handle_table::size.

{
   void *object;
   unsigned index;
   
   assert(ht);
   assert(handle);
   if(!handle || handle > ht->size)
      return;

   index = handle - 1;
   object = ht->objects[index];
   if(!object)
      return;
   
   handle_table_clear(ht, index);

   if(index < ht->filled)
      ht->filled = index;
}

static int handle_table_resize	(	struct handle_table *	ht,
		unsigned	minimum_size
	)			[static]

Resize the table if necessary.

Definition at line 98 of file u_handle_table.c.

References assert, handle_table::objects, REALLOC, and handle_table::size.

{
   unsigned new_size;
   void **new_objects;

   if(ht->size > minimum_size)
      return ht->size;

   new_size = ht->size;
   while(!(new_size > minimum_size))
      new_size *= 2;
   assert(new_size);
   
   new_objects = (void **)REALLOC((void *)ht->objects,
                                  ht->size*sizeof(void *),
                                  new_size*sizeof(void *));
   if(!new_objects)
      return 0;
   
   memset(new_objects + ht->size, 0, (new_size - ht->size)*sizeof(void *));
   
   ht->size = new_size;
   ht->objects = new_objects;
   
   return ht->size;
}

unsigned handle_table_set	(	struct handle_table *	ht,
		unsigned	handle,
		void *	object
	)

Returns zero on failure (out of memory).

Definition at line 188 of file u_handle_table.c.

References assert, handle_table_clear(), handle_table_resize(), and handle_table::objects.

{
   unsigned index;
   
   assert(ht);
   assert(handle);
   if(!handle)
      return 0;

   assert(object);
   if(!object)
      return 0;
   
   index = handle - 1;

   /* grow the table if necessary */
   if(!handle_table_resize(ht, index))
      return 0;

   handle_table_clear(ht, index);

   ht->objects[index] = object;
   
   return handle;
}

void handle_table_set_destroy	(	struct handle_table *	ht,
		void(*)(void *object)	destroy
	)

Set an optional destructor callback.

If set, it will be called during handle_table_remove and handle_table_destroy calls.

Definition at line 86 of file u_handle_table.c.

References assert, and handle_table::destroy.

{
   assert(ht);
   ht->destroy = destroy;
}

---