[svn-r8707] Changed the way HDF5 handles hid_t's and added API functions to allow users to register IDs and ID types at runtime.

1 files changed, 943 insertions, 315 deletions

diff --git a/src/H5I.c b/src/H5I.c
index ecf3169..bf378ee 100644
--- a/src/H5I.c
+++ b/src/H5I.c
@@ -16,13 +16,14 @@
  * FILE:	H5I.c - Internal storage routines for handling "IDs"
  *     
  * REMARKS:	ID's which allow objects (void *'s currently) to be bundled
- *		into "groups" for more general storage.
+ *		into "types" for more general storage.
  * 
- * DESIGN:	The groups are stored in an array of pointers to store each
- *		group in an element. Each "group" node contains a link to a
- *		hash table to manage the IDs in each group.  The allowed
- *		"groups" are stored in an enum (called group_t) in
- *		H5Ipublic.h.
+ * DESIGN:	The types are stored in an array of pointers to store each
+ *		type in an element. Each "type" node contains a link to a
+ *		hash table to manage the IDs in each type.  Allowed types are
+ *		values within the range 1 to MAX_NUM_TYPES and are given out
+ *		at run-time.  Types used by the library are stored in global
+ *		variables defined in H5Ipublic.h.
  *		
  * AUTHOR:	Quincey Koziol
  *
@@ -30,6 +31,7 @@
  *	1/3/96	- Starting writing specs & coding prototype
  *	1/7/96	- Finished coding prototype
  *	6/10/97 - Moved into HDF5 library
+ *	5/18/04 - Expanded to allow registration of new types at run-time
  */
 
 #define H5I_PACKAGE		/*suppress error about including H5Ipkg	  */
@@ -80,8 +82,8 @@ static int interface_initialize_g = 0;
 #  define H5I_LOC(a,s)	(((hid_t)(a)&ID_MASK)%(s))
 #endif
 
-/* Combine a Group number and an atom index into an atom */
-#define H5I_MAKE(g,i)	((((hid_t)(g)&GROUP_MASK)<<ID_BITS)|	  \
+/* Combine a Type number and an atom index into an atom */
+#define H5I_MAKE(g,i)	((((hid_t)(g)&TYPE_MASK)<<ID_BITS)|	  \
 			     ((hid_t)(i)&ID_MASK))
 
 /* Local typedefs */
@@ -94,9 +96,9 @@ typedef struct H5I_id_info_t {
     struct H5I_id_info_t *next;	/* link to next atom (in case of hash-clash)*/
 } H5I_id_info_t;
 
-/* ID group structure used */
+/* ID type structure used */
 typedef struct {
-    unsigned	count;		/*# of times this group has been initialized*/
+    unsigned	count;		/*# of times this type has been initialized*/
     unsigned	reserved;	/*# of IDs to reserve for constant IDs	    */
     unsigned	wrapped;	/*whether the id count has wrapped around   */
     size_t	hash_size;	/*sizeof the hash table to store the IDs in */
@@ -104,12 +106,21 @@ typedef struct {
     unsigned	nextid;		/*ID to use for the next atom		    */
     H5I_free_t	free_func;	/*release object method	    		    */
     H5I_id_info_t **id_list;	/*pointer to an array of ptrs to IDs	    */
-} H5I_id_group_t;
+} H5I_id_type_t;
+
 
 /*-------------------- Locally scoped variables -----------------------------*/
 
-/* Array of pointers to atomic groups */
-static H5I_id_group_t *H5I_id_group_list_g[H5I_NGROUPS];
+/* Array of pointers to atomic types */
+static H5I_id_type_t *H5I_id_type_list_g[MAX_NUM_TYPES];  
+
+/* Variable to keep track of the number of types allocated.  Its value is the */
+/* next type ID to be handed out, so it is always one greater than the number */
+/* of types. */
+/* Starts at 1 instead of 0 because it makes trace output look nicer.  If more */
+/* types (or IDs within a type) are needed, adjust TYPE_BITS in H5Ipkg.h       */
+/* and/or increase size of hid_t */
+static H5I_type_t H5I_next_type = (H5I_type_t) H5I_NTYPES;
 
 /* Declare a free list to manage the H5I_id_info_t struct */
 H5FL_DEFINE_STATIC(H5I_id_info_t);
@@ -120,7 +131,7 @@ static H5I_id_info_t *H5I_find_id(hid_t id);
 static hid_t H5I_get_file_id(hid_t obj_id);
 static int H5I_get_ref(hid_t id);
 #ifdef H5I_DEBUG_OUTPUT
-static herr_t H5I_debug(H5I_type_t grp);
+static herr_t H5I_debug(H5I_type_t type);
 #endif /* H5I_DEBUG_OUTPUT */
 
 
@@ -144,12 +155,6 @@ H5I_init_interface(void)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5I_init_interface);
 
-    /*
-     * Make certain the ID types don't overflow the number of bits allocated
-     * for them in an ID.
-     */
-    assert(H5I_NGROUPS<=(1<<GROUP_BITS));
-
     FUNC_LEAVE_NOAPI(SUCCEED);
 }
 
@@ -159,7 +164,7 @@ H5I_init_interface(void)
  *
  * Purpose:	Terminate the H5I interface: release all memory, reset all
  *		global variables to initial values. This only happens if all
- *		groups have been destroyed from other interfaces.
+ *		types have been destroyed from other interfaces.
  *
  * Return:	Success:	Positive if any action was taken that might
  *				affect some other interface; zero otherwise.
@@ -175,25 +180,25 @@ H5I_init_interface(void)
 int
 H5I_term_interface(void)
 {
-    H5I_id_group_t	*grp_ptr;
-    H5I_type_t		grp;
+    H5I_id_type_t	*type_ptr;
+    H5I_type_t		type;
     int		n=0;
 
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5I_term_interface);
 
     if (interface_initialize_g) {
-        /* How many groups are still being used? */
-        for (grp=(H5I_type_t)0; grp<H5I_NGROUPS; H5_INC_ENUM(H5I_type_t,grp)) {
-            if ((grp_ptr=H5I_id_group_list_g[grp]) && grp_ptr->id_list)
+        /* How many types are still being used? */
+        for (type=(H5I_type_t)0; type<H5I_next_type; H5_INC_ENUM(H5I_type_t,type)) {
+            if ((type_ptr=H5I_id_type_list_g[type]) && type_ptr->id_list)
                 n++;
         }
 
-        /* If no groups are used then clean  up */
+        /* If no types are used then clean up */
         if (0==n) {
-            for (grp=(H5I_type_t)0; grp<H5I_NGROUPS; H5_INC_ENUM(H5I_type_t,grp)) {
-                grp_ptr = H5I_id_group_list_g[grp];
-                H5MM_xfree(grp_ptr);
-                H5I_id_group_list_g[grp] = NULL;
+            for (type=(H5I_type_t)0; type<H5I_next_type; H5_INC_ENUM(H5I_type_t,type)) {
+                type_ptr = H5I_id_type_list_g[type];
+                H5MM_xfree(type_ptr);
+                H5I_id_type_list_g[type] = NULL;
             }
         }
 
@@ -202,31 +207,69 @@ H5I_term_interface(void)
     }
     FUNC_LEAVE_NOAPI(n);
 }
-
-
 /*-------------------------------------------------------------------------
- * Function:	H5I_init_group
- *
- * Purpose:	Initialize an ID group whose ID number is specified by GRP,
- *		If the group has already been initialized, this routine just
- *		increments the count of number of initializations and returns
- *		without trying to change the size of the hash table.  A
- *		specific number (RESERVED) of group entries may be reserved
- *		to enable "constant" values to be handed out which are valid
- *		IDs in the group, but which do not map to any data structures
- *		and are not allocated dynamicly later. HASH_SIZE is the
- *		minimum hash table size to use for the group. FREE_FUNC is
+ * Function:	H5Iregister_type
+ *
+ * Purpose:	Public interface to H5I_register_type.  Creates a new type
+ *		of ID's to give out.  A specific number (RESERVED) of type 
+ *		entries may be reserved to enable "constant" values to be handed 
+ *		out which are valid IDs in the type, but which do not map to any 
+ *		data structures and are not allocated dynamically later. HASH_SIZE is 
+ *		the minimum hash table size to use for the type. FREE_FUNC is
  *		called with an object pointer when the object is removed from
- *		the group.
+ *		the type.
  *
- * Return:	Success:	Non-negative
+ * Return:	Success:	Type ID of the new type
  *
- *		Failure:	Negative
+ *		Failure:	H5I_BADID
  *
- * Programmer:	Robb Matzke
- *		Friday, February 19, 1999
+ * Programmers:	Nathaniel Furrer
+ *				James Laird
+ *		Friday, April 30, 2004
  *
  * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5I_type_t H5Iregister_type(size_t hash_size, unsigned reserved, H5I_free_t free_func)
+{
+	H5I_type_t ret_value;
+	FUNC_ENTER_API(H5Iregister_type, H5I_BADID);
+
+		/* Call H5I_register_type with a value of 0 to get a new type */
+	ret_value = H5I_register_type(0, hash_size, reserved, free_func);
+
+done:
+	FUNC_LEAVE_API(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_register_type
+ *
+ * Purpose:	Creates a new type of ID's to give out.  A specific number
+ *		(RESERVED) of type entries may be reserved to enable "constant"
+ *		values to be handed out which are valid IDs in the type, but
+ *		which do not map to any data structures and are not allocated
+ *		dynamically later. TYPE_ID is the H5I_type_t value of the type
+ *		to be initialized.  If this value is zero, a new type is created.
+ *		If this value is one of the library types, that type is
+ *		initialized or its reference count is incremented (if it is already
+ *		initialized).  HASH_SIZE is the minimum hash table size to
+ *		use for the type. FREE_FUNC is called with an object pointer
+ *		when the object is removed from the type.
+ *
+ * Return:	Success:	Type ID of the new type
+ *		Failure:	H5I_BADID
+ *
+ * Programmers:	Nathaniel Furrer
+ *				James Laird
+ *		Friday, April 30, 2004
+ *
+ * Modifications: The initialization section of this function was formerly
+ *					H5I_init_type, programmed by Robb Matzke on February 19,
+ *					1999.
+ *
  * 		Bill Wendling, 2000-05-05
  * 		Instead of the ugly test of whether hash_size is a power of
  * 		two, I placed it in a macro POWER_OF_TWO which uses the fact
@@ -238,68 +281,142 @@ H5I_term_interface(void)
  *
  *-------------------------------------------------------------------------
  */
-int 
-H5I_init_group(H5I_type_t grp, size_t hash_size, unsigned reserved,
-	       H5I_free_t free_func)
+
+H5I_type_t H5I_register_type(H5I_type_t type_id, size_t hash_size, unsigned reserved, H5I_free_t free_func)
 {
-    H5I_id_group_t	*grp_ptr = NULL;	/*ptr to the atomic group*/
-    int		ret_value = SUCCEED;	/*return value		*/
+	H5I_type_t ret_value;                   /* type ID to return */
+    H5I_id_type_t	*type_ptr = NULL;		/*ptr to the atomic type*/
+	int i;
+	int done;
+
+    FUNC_ENTER_NOAPI(H5I_register_type, H5I_BADID);
 
-    FUNC_ENTER_NOAPI(H5I_init_group, FAIL);
+	/* Check that type_id is either a library type or zero */
+	if(type_id < 0 || type_id >= H5I_NTYPES)
+	{
+		HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, H5I_BADID, "invalid type ID");
+	}
+
+	if(type_id == 0)	/* Generate a new H5I_type_t value */
+	{
+		/* Increment the number of types*/
+		if (H5I_next_type < MAX_NUM_TYPES)
+		{
+			ret_value = H5I_next_type;
+			H5I_next_type++;
+		}
+		else
+		{
+			done = 0;
+			/* Look for a free type to give out */
+			for(i = H5I_NTYPES; i < MAX_NUM_TYPES && done==0; i++)
+			{
+				if(H5I_id_type_list_g[i] == NULL)
+				{
+					/* Found a free type ID */
+					ret_value = i;
+					done = 1;
+				}
+			}
+
+			/* Verify that we found a type to give out */
+			if(done == 0)
+				HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5I_BADID, "Maximum number of ID types exceeded.");
+		}
+	}
+	else	/* type_id is a library type; use this value. */
+	{
+		ret_value = type_id;
+	}
+	
+	/* Initialize the type */
 
     /* Check arguments */
-    if ((grp <= H5I_BADID || grp >= H5I_NGROUPS) && hash_size > 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
 #ifdef HASH_SIZE_POWER_2
     if (!POWER_OF_TWO(hash_size) || hash_size == 1)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid hash size");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, H5I_BADID, "invalid hash size");
 #endif /* HASH_SIZE_POWER_2 */
 
-    if (H5I_id_group_list_g[grp] == NULL) {
-	/* Allocate the group information for new group */
-	if (NULL==(grp_ptr = H5MM_calloc(sizeof(H5I_id_group_t))))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
-	H5I_id_group_list_g[grp] = grp_ptr;
+    if (H5I_id_type_list_g[ret_value] == NULL) {
+	/* Allocate the type information for new type */
+	if (NULL==(type_ptr = H5MM_calloc(sizeof(H5I_id_type_t))))
+	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, H5I_BADID, "memory allocation failed");
+		H5I_id_type_list_g[ret_value] = type_ptr;
     } else {
-	/* Get the pointer to the existing group */
-	grp_ptr = H5I_id_group_list_g[grp];
+		/* Get the pointer to the existing type */
+		type_ptr = H5I_id_type_list_g[ret_value];
     }
 
-    if (grp_ptr->count == 0) {
-	/* Initialize the ID group structure for new groups */
-	grp_ptr->hash_size = hash_size;
-	grp_ptr->reserved = reserved;
-	grp_ptr->wrapped = 0;
-	grp_ptr->ids = 0;
-	grp_ptr->nextid = reserved;
-	grp_ptr->free_func = free_func;
-	grp_ptr->id_list = H5MM_calloc(hash_size*sizeof(H5I_id_info_t *));
-	if (NULL==grp_ptr->id_list)
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+    if (type_ptr->count == 0) {
+		/* Initialize the ID type structure for new types */
+		type_ptr->hash_size = hash_size;
+		type_ptr->reserved = reserved;
+		type_ptr->wrapped = 0;
+		type_ptr->ids = 0;
+		type_ptr->nextid = reserved;
+		type_ptr->free_func = free_func;
+		type_ptr->id_list = H5MM_calloc(hash_size*sizeof(H5I_id_info_t *));
+		if (NULL==type_ptr->id_list)
+			HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, H5I_BADID, "memory allocation failed");
     }
-    
-    /* Increment the count of the times this group has been initialized */
-    grp_ptr->count++;
 
-done:
-    if (ret_value<0) {
-	/* Error condition cleanup */
-	if (grp_ptr != NULL) {
-	    H5MM_xfree(grp_ptr->id_list);
-	    H5MM_xfree(grp_ptr);
+    /* Increment the count of the times this type has been initialized */
+    type_ptr->count++;
+
+	done:
+	if(ret_value == H5I_BADID)	/* Clean up on error */
+	{
+		if (type_ptr != NULL)
+		{
+			H5MM_xfree(type_ptr->id_list);
+			H5MM_xfree(type_ptr);
+		}
 	}
-    }
 
-    FUNC_LEAVE_NOAPI(ret_value);
+	FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
+/*-------------------------------------------------------------------------
+ * Function:	H5Inmembers
+ *
+ * Purpose:	Returns the number of members in a type.  Public interface to
+ *			H5I_nmembers.
+ *
+ * Return:	Success:	Number of members; zero if the type is empty
+ *				or has been deleted.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	James Laird
+ *				Nathaniel Furrer
+ *              Friday, April 23, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int H5Inmembers(H5I_type_t type)
+{
+	int ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Inmembers, FAIL);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_nmembers(type);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
 /*-------------------------------------------------------------------------
  * Function:	H5I_nmembers
  *
- * Purpose:	Returns the number of members in a group.
+ * Purpose:	Returns the number of members in a type.
  *
- * Return:	Success:	Number of members; zero if the group is empty
+ * Return:	Success:	Number of members; zero if the type is empty
  *				or has been deleted.
  *
  *		Failure:	Negative
@@ -312,9 +429,9 @@ done:
  *-------------------------------------------------------------------------
  */
 int
-H5I_nmembers(H5I_type_t grp)
+H5I_nmembers(H5I_type_t type)
 {
-    H5I_id_group_t	*grp_ptr = NULL;
+    H5I_id_type_t	*type_ptr = NULL;
     H5I_id_info_t	*cur=NULL;
     int		n=0;
     unsigned		i;
@@ -322,13 +439,13 @@ H5I_nmembers(H5I_type_t grp)
 
     FUNC_ENTER_NOAPI(H5I_nmembers, FAIL);
 
-    if (grp<=H5I_BADID || grp>=H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    if (NULL==(grp_ptr=H5I_id_group_list_g[grp]) || grp_ptr->count<=0)
+    if (type<=H5I_BADID || type>=H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+    if (NULL==(type_ptr=H5I_id_type_list_g[type]) || type_ptr->count<=0)
 	HGOTO_DONE(0);
 
-    for (i=0; i<grp_ptr->hash_size; i++)
-	for (cur=grp_ptr->id_list[i]; cur; cur=cur->next)
+    for (i=0; i<type_ptr->hash_size; i++)
+	for (cur=type_ptr->id_list[i]; cur; cur=cur->next)
 	    n++;
 
     /* Set return value */
@@ -338,11 +455,45 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
 /*-------------------------------------------------------------------------
- * Function:	H5I_clear_group
+ * Function:	H5Iclear_type
  *
- * Purpose:	Removes all objects from the group, calling the free
+ * Purpose:	Removes all objects from the type, calling the free
+ *		function for each object regardless of the reference count.
+ *		Public interface to H5I_clear_type.
+ *
+ * Return:	Success:	Non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	James Laird
+ *				Nathaniel Furrer
+ *              Friday, April 23, 2004
+ *
+ * Modifications:
+ *-------------------------------------------------------------------------
+ */
+herr_t H5Iclear_type(H5I_type_t type, hbool_t force)
+{
+	herr_t ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Iclear_type, FAIL);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_clear_type(type, force);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_clear_type
+ *
+ * Purpose:	Removes all objects from the type, calling the free
  *		function for each object regardless of the reference count.
  *
  * Return:	Success:	Non-negative
@@ -368,9 +519,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5I_clear_group(H5I_type_t grp, hbool_t force)
+H5I_clear_type(H5I_type_t type, hbool_t force)
 {
-    H5I_id_group_t  *grp_ptr = NULL;    /* ptr to the atomic group */
+    H5I_id_type_t  *type_ptr = NULL;    /* ptr to the atomic type */
     H5I_id_info_t   *cur=NULL;          /* Current node being worked with */
     H5I_id_info_t   *next=NULL;         /* Next node in list */
     H5I_id_info_t   *last=NULL;         /* Last node seen */
@@ -379,22 +530,22 @@ H5I_clear_group(H5I_type_t grp, hbool_t force)
     unsigned    delete_node;            /* Flag to indicate node should be removed from linked list */
     unsigned	i;
 
-    FUNC_ENTER_NOAPI(H5I_clear_group, FAIL);
+    FUNC_ENTER_NOAPI(H5I_clear_type, FAIL);
 
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
     
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
 
     /*
-     * Call free method for all objects in group regardless of their reference
+     * Call free method for all objects in type regardless of their reference
      * counts. Ignore the return value from from the free method and remove
-     * object from group regardless if FORCE is non-zero.
+     * object from type regardless if FORCE is non-zero.
      */
-    for (i=0; i<grp_ptr->hash_size; i++) {
-        for (cur=grp_ptr->id_list[i]; cur; cur=next) {
+    for (i=0; i<type_ptr->hash_size; i++) {
+        for (cur=type_ptr->id_list[i]; cur; cur=next) {
             /*
              * Do nothing to the object if the reference count is larger than
              * one and forcing is off.
@@ -405,12 +556,12 @@ H5I_clear_group(H5I_type_t grp, hbool_t force)
             } /* end if */
 
             /* Check for a 'free' function and call it, if it exists */
-            if (grp_ptr->free_func && (grp_ptr->free_func)(cur->obj_ptr)<0) {
+            if (type_ptr->free_func && (type_ptr->free_func)(cur->obj_ptr)<0) {
                 if (force) {
 #ifdef H5I_DEBUG
                     if (H5DEBUG(I)) {
-                        fprintf(H5DEBUG(I), "H5I: free grp=%d obj=0x%08lx "
-                            "failure ignored\n", (int)grp,
+                        fprintf(H5DEBUG(I), "H5I: free type=%d obj=0x%08lx "
+                            "failure ignored\n", (int)type,
                             (unsigned long)(cur->obj_ptr));
                     } /* end if */
 #endif /*H5I_DEBUG*/
@@ -430,8 +581,8 @@ H5I_clear_group(H5I_type_t grp, hbool_t force)
 
             /* Check if we should delete this node or not */
             if(delete_node) {
-                /* Decrement the number of IDs in the group */
-                (grp_ptr->ids)--;
+                /* Decrement the number of IDs in the type */
+                (type_ptr->ids)--;
 
                 /* Advance to next node */
                 next = cur->next;
@@ -442,7 +593,7 @@ H5I_clear_group(H5I_type_t grp, hbool_t force)
                 /*      make an H5I call, which could potentially change the */
                 /*      order of the nodes on the list - QAK) */
                 last=NULL;
-                tmp=grp_ptr->id_list[i];
+                tmp=type_ptr->id_list[i];
                 while(tmp!=cur) {
                     assert(tmp!=NULL);
                     last=tmp;
@@ -452,8 +603,8 @@ H5I_clear_group(H5I_type_t grp, hbool_t force)
                 /* Delete the node from the list */
                 if(last==NULL) {
                     /* Node at head of list, just advance the list head to next node */
-                    assert(grp_ptr->id_list[i]==cur);
-                    grp_ptr->id_list[i] = next;
+                    assert(type_ptr->id_list[i]==cur);
+                    type_ptr->id_list[i] = next;
                 } /* end if */
                 else {
                     /* Node in middle of list, jump over it */
@@ -475,71 +626,126 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
 /*-------------------------------------------------------------------------
- * Function:	H5I_destroy_group
+ * Function:	H5Idestroy_type
  *
- * Purpose:	Decrements the reference count on an entire group of IDs.
- *		If the group reference count becomes zero then the group is
- *		destroyed along with all atoms in that group regardless of
- *		their reference counts.	 Destroying IDs involves calling
- *		the free-func for each ID's object and then adding the ID
- *		struct to the ID free list.
+ * Purpose:	Destroys a type along with all atoms in that type
+ *		regardless of their reference counts. Destroying IDs
+ *		involves calling the free-func for each ID's object and
+ *		then adding the ID struct to the ID free list.  Public
+ *		interface to H5I_destroy_type.
  *		
- * Return:	Non-negative on success/Negative on failure
+ * Return:	Zero on success/Negative on failure
  *
- * Programmer:	Unknown
+ * Programmer:	Nathaniel Furrer
+ *				James Laird
  *
  * Modifications:
  *
- *	Robb Matzke, 25 Feb 1998
- *	IDs are freed when a group is destroyed.
+ *-------------------------------------------------------------------------
+ */
+herr_t H5Idestroy_type(H5I_type_t type)
+{
+	herr_t ret_value;
+
+	FUNC_ENTER_API(H5Idestroy_type, FAIL);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_destroy_type(type);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_destroy_type
+ *
+ * Purpose:	Destroys a type along with all atoms in that type
+ *		regardless of their reference counts. Destroying IDs
+ *		involves calling the free-func for each ID's object and
+ *		then adding the ID struct to the ID free list.
+ *
+ * Return:	Zero on success/Negative on failure
+ *
+ * Programmer:	Nathaniel Furrer
+ *				James Laird
+ *
+ * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5I_destroy_group(H5I_type_t grp)
+herr_t H5I_destroy_type(H5I_type_t type)
 {
-    H5I_id_group_t	*grp_ptr = NULL;	/* ptr to the atomic group */
-    int		ret_value = SUCCEED;
+	herr_t ret_value = FAIL;
+    H5I_id_type_t *type_ptr = NULL;	/* ptr to the atomic type */
 
-    FUNC_ENTER_NOAPI(H5I_destroy_group, FAIL);
+	FUNC_ENTER_NOAPI(H5I_destroy_type, FAIL);
 
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
+    if (type <= H5I_BADID || type >= H5I_next_type)
+		HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
 
-    /*
-     * Decrement the number of users of the atomic group.  If this is the
-     * last user of the group then release all atoms from the group.  The
-     * free function is invoked for each atom being freed.
-     */
-    if (1==grp_ptr->count) {
-        H5I_clear_group(grp, TRUE);
-        H5E_clear(NULL); /*don't care about errors*/
-        H5MM_xfree(grp_ptr->id_list);
-        HDmemset (grp_ptr, 0, sizeof(*grp_ptr));
-    } else {
-        --(grp_ptr->count);
-    }
-    
-  done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
+
+	H5I_clear_type(type, TRUE);
+	H5E_clear(NULL); /*don't care about errors*/
+	H5MM_xfree(type_ptr->id_list);
+
+	H5MM_free(type_ptr);
+	H5I_id_type_list_g[type] = NULL;
+	ret_value = 0;
+
+done:
+	FUNC_LEAVE_NOAPI(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Iregister
+ *
+ * Purpose:	Public interface to H5I_register.
+ *
+ * Return:	Success:	New object id.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	Nathaniel Furrer
+ *				James Laird
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t H5Iregister(H5I_type_t type, void *object)
+{
+	hid_t ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Iregister, H5I_INVALID_HID);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_register(type, object);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:	H5I_register
  *
- * Purpose:	Registers an OBJECT in a GROUP and returns an ID for it.
+ * Purpose:	Registers an OBJECT in a TYPE and returns an ID for it.
  *		This routine does _not_ check for unique-ness of the objects,
  *		if you register an object twice, you will get two different
  *		IDs for it.  This routine does make certain that each ID in a
- *		group is unique.  IDs are created by getting a unique number
- *		for the group the ID is in and incorporating the group into
+ *		type is unique.  IDs are created by getting a unique number
+ *		for the type the ID is in and incorporating the type into
  *		the ID which is returned to the user.
  *
  * Return:	Success:	New object id.
@@ -553,9 +759,9 @@ H5I_destroy_group(H5I_type_t grp)
  *-------------------------------------------------------------------------
  */
 hid_t 
-H5I_register(H5I_type_t grp, void *object)
+H5I_register(H5I_type_t type, void *object)
 {
-    H5I_id_group_t	*grp_ptr=NULL;	/*ptr to the group		*/
+    H5I_id_type_t	*type_ptr=NULL;	/*ptr to the type		*/
     H5I_id_info_t	*id_ptr=NULL;	/*ptr to the new ID information */
     hid_t		new_id;		/*new ID			*/
     unsigned		hash_loc;	/*new item's hash table location*/
@@ -567,61 +773,61 @@ H5I_register(H5I_type_t grp, void *object)
     FUNC_ENTER_NOAPI(H5I_register, FAIL);
 
     /* Check arguments */
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
     if ((id_ptr = H5FL_MALLOC(H5I_id_info_t)) == NULL)
         HGOTO_ERROR(H5E_ATOM, H5E_NOSPACE, FAIL, "memory allocation failed");
 
     /* Create the struct & it's ID */
-    new_id = H5I_MAKE(grp, grp_ptr->nextid);
+    new_id = H5I_MAKE(type, type_ptr->nextid);
     id_ptr->id = new_id;
     id_ptr->count = 1; /*initial reference count*/
     id_ptr->obj_ptr = object;
     id_ptr->next = NULL;
 
     /* hash bucket already full, prepend to front of chain */
-    hash_loc = grp_ptr->nextid % (unsigned) grp_ptr->hash_size;
-    if (grp_ptr->id_list[hash_loc] != NULL)
-	id_ptr->next = grp_ptr->id_list[hash_loc];
+    hash_loc = type_ptr->nextid % (unsigned) type_ptr->hash_size;
+    if (type_ptr->id_list[hash_loc] != NULL)
+	id_ptr->next = type_ptr->id_list[hash_loc];
 
-    /* Insert into the group */
-    grp_ptr->id_list[hash_loc] = id_ptr;
-    grp_ptr->ids++;
-    grp_ptr->nextid++;
+    /* Insert into the type */
+    type_ptr->id_list[hash_loc] = id_ptr;
+    type_ptr->ids++;
+    type_ptr->nextid++;
 
     /*
      * This next section of code checks for the 'nextid' getting too large and
      * wrapping around, thus necessitating checking for duplicate IDs being
      * handed out.
      */
-    if (grp_ptr->nextid > (unsigned)ID_MASK) {
-	grp_ptr->wrapped = 1;
-	grp_ptr->nextid = grp_ptr->reserved;
+    if (type_ptr->nextid > (unsigned)ID_MASK) {
+	type_ptr->wrapped = 1;
+	type_ptr->nextid = type_ptr->reserved;
     }
 
     /*
      * If we've wrapped around then we need to check for duplicate id's being
      * handed out.
      */
-    if (grp_ptr->wrapped) {
+    if (type_ptr->wrapped) {
 	/*
 	 * Make sure we check all available ID's.  If we're about at the end
 	 * of the range then wrap around and check the beginning values.  If
 	 * we check all possible values and didn't find any free ones *then*
 	 * we can fail.
 	 */
-	for (i=grp_ptr->reserved; i<ID_MASK; i++) {
+	for (i=type_ptr->reserved; i<ID_MASK; i++) {
 	    /* Handle end of range by wrapping to beginning */
-	    if (grp_ptr->nextid>(unsigned)ID_MASK)
-		grp_ptr->nextid = grp_ptr->reserved;
+	    if (type_ptr->nextid>(unsigned)ID_MASK)
+		type_ptr->nextid = type_ptr->reserved;
 
 	    /* new ID to check for */
-	    next_id = H5I_MAKE(grp, grp_ptr->nextid);
-	    hash_loc = H5I_LOC (grp_ptr->nextid, grp_ptr->hash_size);
-	    curr_id = grp_ptr->id_list[hash_loc];
+	    next_id = H5I_MAKE(type, type_ptr->nextid);
+	    hash_loc = H5I_LOC (type_ptr->nextid, type_ptr->hash_size);
+	    curr_id = type_ptr->id_list[hash_loc];
 	    if (curr_id == NULL)
                 break; /* Ha! this is not likely... */
 
@@ -632,12 +838,12 @@ H5I_register(H5I_type_t grp, void *object)
 	    }
 	    if (!curr_id)
                 break; /* must not have found a match */
-	    grp_ptr->nextid++;
+	    type_ptr->nextid++;
 	}
 
 	if (i>=(unsigned)ID_MASK)
 	    /* All the IDs are gone! */
-            HGOTO_ERROR(H5E_ATOM, H5E_NOIDS, FAIL, "no IDs available in group");
+            HGOTO_ERROR(H5E_ATOM, H5E_NOIDS, FAIL, "no IDs available in type");
     }
     ret_value = new_id;
 
@@ -680,12 +886,48 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
+/*-------------------------------------------------------------------------
+ * Function:	H5Iobject_verify
+ *
+ * Purpose:	Find an object pointer for the specified ID, verifying that
+ *                  its in a particular type.  Public interface to 
+ *					H5I_object_verify.
+ *
+ * Return:	Success:	Non-null object pointer associated with the
+ *				specified ID.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Nathaniel Furrer
+ *				James Laird
+ *		Friday, April 23, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void *H5Iobject_verify(hid_t id, H5I_type_t id_type)
+{
+	void * ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Iobject_verify, NULL);
+
+	if( H5I_IS_LIB_TYPE( id_type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_object_verify(id, id_type);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
 /*-------------------------------------------------------------------------
  * Function:	H5I_object_verify
  *
  * Purpose:	Find an object pointer for the specified ID, verifying that
- *                  its in a particular group.
+ *                  its in a particular type.
  *
  * Return:	Success:	Non-null object pointer associated with the
  *				specified ID.
@@ -707,10 +949,10 @@ H5I_object_verify(hid_t id, H5I_type_t id_type)
 
     FUNC_ENTER_NOAPI(H5I_object_verify, NULL);
 
-    assert(id_type>=H5I_FILE && id_type<H5I_NGROUPS);
+    assert(id_type>=1 && id_type<H5I_next_type);
 
-    /* Verify that the group of the ID is correct & lookup the ID */
-    if(id_type == H5I_GRP(id) && NULL!=(id_ptr = H5I_find_id(id))) {
+    /* Verify that the type of the ID is correct & lookup the ID */
+    if(id_type == H5I_TYPE(id) && NULL!=(id_ptr = H5I_find_id(id))) {
         /* Get the object pointer to return */
         ret_value = id_ptr->obj_ptr;
     } /* end if */
@@ -723,12 +965,12 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5I_get_type
  *
- * Purpose:	Given an object ID return the group (type) to which it
+ * Purpose:	Given an object ID return the type to which it
  *		belongs.  The ID need not be the ID of an object which
- *		currently exists because the group number (type) is encoded
+ *		currently exists because the type number is encoded
  *		in the object ID.
  *
- * Return:	Success:	A valid group number (type)
+ * Return:	Success:	A valid type number
  *
  *		Failure:	H5I_BADID, a negative value.
  *
@@ -747,9 +989,9 @@ H5I_get_type(hid_t id)
     FUNC_ENTER_NOAPI(H5I_get_type, H5I_BADID);
 
     if (id>0)
-        ret_value = H5I_GRP(id);
+        ret_value = H5I_TYPE(id);
 
-    assert(ret_value>=H5I_BADID && ret_value<H5I_NGROUPS);
+    assert(ret_value>=H5I_BADID && ret_value<H5I_next_type);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -759,12 +1001,12 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5Iget_type
  *
- * Purpose:	The public version of H5I_get_type(), obtains a group number
- *		(type) when given an ID.  The ID need not be the ID of an
- *		object which currently exists because the group number is
+ * Purpose:	The public version of H5I_get_type(), obtains a type number
+ *		when given an ID.  The ID need not be the ID of an
+ *		object which currently exists because the type number is
  *		encoded as part of the ID.
  *
- * Return:	Success:	Group number (type)
+ * Return:	Success:	Type number
  *
  *		Failure:	H5I_BADID, a negative value
  *
@@ -772,7 +1014,7 @@ done:
  *
  * Modifications:
  *		Robb Matzke, 1999-08-23
- *		Also fails if the ID has a valid group but no longer exists
+ *		Also fails if the ID has a valid type but no longer exists
  *		in the ID tables.
  *-------------------------------------------------------------------------
  */
@@ -786,7 +1028,7 @@ H5Iget_type(hid_t id)
 
     ret_value = H5I_get_type(id);
 
-    if (ret_value <= H5I_BADID || ret_value >= H5I_NGROUPS || NULL==H5I_object(id))
+    if (ret_value <= H5I_BADID || ret_value >= H5I_next_type || NULL==H5I_object(id))
 	HGOTO_DONE(H5I_BADID);
 
 done:
@@ -849,47 +1091,120 @@ H5I_get_file_id(hid_t obj_id)
 {
     H5G_entry_t         *ent;
     hid_t		ret_value;
+	H5I_type_t type;
 
     FUNC_ENTER_NOAPI_NOINIT(H5I_get_file_id);
 
     /* Get object type */
-    switch(H5I_GRP(obj_id)) {
-        case H5I_FILE:
-            ret_value = obj_id;
-            
-            /* Increment reference count on atom. */
-            if (H5I_inc_ref(ret_value)<0)
-                HGOTO_ERROR (H5E_ATOM, H5E_CANTSET, FAIL, "incrementing file ID failed");
+	type = H5I_TYPE(obj_id);
+	if(type == H5I_FILE)
+	{
+        ret_value = obj_id;
+        
+        /* Increment reference count on atom. */
+        if (H5I_inc_ref(ret_value)<0)
+            HGOTO_ERROR (H5E_ATOM, H5E_CANTSET, FAIL, "incrementing file ID failed");
+	}
+	else if(type == H5I_DATATYPE)
+	{
+        if((ent = H5G_loc(obj_id))==NULL)
+            HGOTO_ERROR (H5E_ATOM, H5E_CANTGET, FAIL, "not a named datatype");
+        ret_value = H5F_get_id(ent->file);
+	}
+	else if(type == H5I_GROUP || type == H5I_DATASET || type == H5I_ATTR)
+	{
+        if((ent = H5G_loc(obj_id))==NULL)
+            HGOTO_ERROR (H5E_ATOM, H5E_CANTGET, FAIL, "can't get symbol table info");
+        ret_value = H5F_get_id(ent->file);
+	}
+	else
+		HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid object ID");
 
-            break;
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
 
-        case H5I_DATATYPE:
-            if((ent = H5G_loc(obj_id))==NULL)
-                HGOTO_ERROR (H5E_ATOM, H5E_CANTGET, FAIL, "not a named datatype");
-            ret_value = H5F_get_id(ent->file);
-            break;
+/*-------------------------------------------------------------------------
+ * Function:	H5Iremove_verify
+ *
+ * Purpose:	Removes the specified ID from its type, first checking that the
+ *			type of the ID and the type type are the same.  Public interface to
+ *			H5I_remove_verify.
+ *
+ * Return:	Success:	A pointer to the object that was removed, the
+ *				same pointer which would have been found by
+ *				calling H5I_object().
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	James Laird
+ *				Nathaniel Furrer
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void *H5Iremove_verify(hid_t id, H5I_type_t id_type)
+{
+	void * ret_value;                      /* Return value */
 
-        case H5I_GROUP:
-        case H5I_DATASET:
-        case H5I_ATTR:
-            if((ent = H5G_loc(obj_id))==NULL)
-                HGOTO_ERROR (H5E_ATOM, H5E_CANTGET, FAIL, "can't get symbol table info");
-            ret_value = H5F_get_id(ent->file);
-            break;
+    FUNC_ENTER_API(H5Iremove_verify, NULL);
+
+	if( H5I_IS_LIB_TYPE( id_type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "cannot call public function on library type");
+	}
+
+	/* Remove the id */
+	ret_value = H5I_remove_verify(id, id_type);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_remove_verify
+ *
+ * Purpose:	Removes the specified ID from its type, first checking that
+ *			the ID's type is the same as the ID type supplied as an argument
+ *
+ * Return:	Success:	A pointer to the object that was removed, the
+ *				same pointer which would have been found by
+ *				calling H5I_object().
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	James Laird
+ *				Nat Furrer
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void * 
+H5I_remove_verify(hid_t id, H5I_type_t id_type)
+{
+    void * ret_value = NULL;	/*return value			*/
+
+    FUNC_ENTER_NOAPI(H5I_remove_verify, NULL);
 
-        default:
-	    HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid object ID");
-    } 
+	/* Argument checking will be performed by H5I_remove() */
+
+    /* Verify that the type of the ID is correct */
+    if(id_type == H5I_TYPE(id))
+	{
+        ret_value = H5I_remove(id);
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
+
 /*-------------------------------------------------------------------------
  * Function:	H5I_remove
  *
- * Purpose:	Removes the specified ID from its group.
+ * Purpose:	Removes the specified ID from its type.
  *
  * Return:	Success:	A pointer to the object that was removed, the
  *				same pointer which would have been found by
@@ -906,26 +1221,26 @@ done:
 void * 
 H5I_remove(hid_t id)
 {
-    H5I_id_group_t	*grp_ptr = NULL;/*ptr to the atomic group	*/
+    H5I_id_type_t	*type_ptr = NULL;/*ptr to the atomic type	*/
     H5I_id_info_t	*curr_id;	/*ptr to the current atom	*/
     H5I_id_info_t	*last_id;	/*ptr to the last atom		*/
-    H5I_type_t		grp;		/*atom's atomic group		*/
+    H5I_type_t		type;		/*atom's atomic type		*/
     unsigned		hash_loc;	/*atom's hash table location	*/
     void *	      ret_value = NULL;	/*return value			*/
 
     FUNC_ENTER_NOAPI(H5I_remove, NULL);
 
     /* Check arguments */
-    grp = H5I_GRP(id);
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "invalid group");
+    type = H5I_TYPE(id);
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "invalid type");
 
     /* Get the bucket in which the ID is located */
-    hash_loc = (unsigned) H5I_LOC(id, grp_ptr->hash_size);
-    curr_id = grp_ptr->id_list[hash_loc];
+    hash_loc = (unsigned) H5I_LOC(id, type_ptr->hash_size);
+    curr_id = type_ptr->id_list[hash_loc];
     if (curr_id == NULL)
 	HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, NULL, "invalid ID");
 
@@ -940,7 +1255,7 @@ H5I_remove(hid_t id)
     if (curr_id != NULL) {
         if (last_id == NULL) {
             /* ID is the first in the chain */
-            grp_ptr->id_list[hash_loc] = curr_id->next;
+            type_ptr->id_list[hash_loc] = curr_id->next;
         } else {
             last_id->next = curr_id->next;
         }
@@ -951,14 +1266,14 @@ H5I_remove(hid_t id)
 	HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, NULL, "invalid ID");
     }
 
-    /* Decrement the number of IDs in the group */
-    (grp_ptr->ids)--;
+    /* Decrement the number of IDs in the type */
+    (type_ptr->ids)--;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
-
+
 /*-------------------------------------------------------------------------
  * Function:	H5Idec_ref
  *
@@ -1001,10 +1316,10 @@ done:
  * Function:	H5I_dec_ref
  *
  * Purpose:	Decrements the number of references outstanding for an ID.
- *		This will fail if the group is not a reference counted group.
- *		The ID group's 'free' function will be called for the ID
+ *		This will fail if the type is not a reference counted type.
+ *		The ID type's 'free' function will be called for the ID
  *		if the reference count for the ID reaches 0 and a free
- *		function has been defined at group creation time.
+ *		function has been defined at type creation time.
  *
  * Return:	Success:	New reference count.
  *
@@ -1025,8 +1340,8 @@ done:
  *
  *	Robb Matzke, 19 Feb 1999
  *	If the free method is defined and fails then the object is not
- *	removed from the group and its reference count is not decremented.
- *	The group number is now passed to the free method.
+ *	removed from the type and its reference count is not decremented.
+ *	The type number is now passed to the free method.
  *
  *	Raymond, 11 Dec 2001
  *	If the freeing function fails, return failure instead of reference
@@ -1038,8 +1353,8 @@ done:
 int
 H5I_dec_ref(hid_t id)
 {
-    H5I_type_t		grp;		/*group the object is in*/
-    H5I_id_group_t	*grp_ptr;	/*ptr to the group	*/
+    H5I_type_t		type;		/*type the object is in*/
+    H5I_id_type_t	*type_ptr;	/*ptr to the type	*/
     H5I_id_info_t	*id_ptr;	/*ptr to the new ID	*/
     int ret_value;                      /* Return value */
 
@@ -1049,29 +1364,29 @@ H5I_dec_ref(hid_t id)
     assert(id>=0);
 
     /* Check arguments */
-    grp = H5I_GRP(id);
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
+    type = H5I_TYPE(id);
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
     
     /* General lookup of the ID */
     if ((id_ptr=H5I_find_id(id))==NULL)
 	HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't locate ID");
 
     /*
-     * If this is the last reference to the object then invoke the group's
+     * If this is the last reference to the object then invoke the type's
      * free method on the object. If the free method is undefined or
-     * successful then remove the object from the group; otherwise leave
-     * the object in the group without decrementing the reference
+     * successful then remove the object from the type; otherwise leave
+     * the object in the type without decrementing the reference
      * count. If the reference count is more than one then decrement the
      * reference count without calling the free method.
      *
      * Beware: the free method may call other H5I functions.
      */
     if (1==id_ptr->count) {
-        if (!grp_ptr->free_func || (grp_ptr->free_func)(id_ptr->obj_ptr)>=0) {
+        if (!type_ptr->free_func || (type_ptr->free_func)(id_ptr->obj_ptr)>=0) {
             H5I_remove(id);
             ret_value = 0;
         } else {
@@ -1141,8 +1456,8 @@ done:
 int
 H5I_inc_ref(hid_t id)
 {
-    H5I_type_t		grp;		/*group the object is in*/
-    H5I_id_group_t	*grp_ptr;	/*ptr to the group	*/
+    H5I_type_t		type;		/*type the object is in*/
+    H5I_id_type_t	*type_ptr;	/*ptr to the type	*/
     H5I_id_info_t	*id_ptr;	/*ptr to the ID		*/
     int ret_value;                      /* Return value */
 
@@ -1152,12 +1467,12 @@ H5I_inc_ref(hid_t id)
     assert(id>=0);
 
     /* Check arguments */
-    grp = H5I_GRP(id);
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (!grp_ptr || grp_ptr->count<=0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
+    type = H5I_TYPE(id);
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (!type_ptr || type_ptr->count<=0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
 
     /* General lookup of the ID */
     if (NULL==(id_ptr=H5I_find_id(id)))
@@ -1226,8 +1541,8 @@ done:
 static int
 H5I_get_ref(hid_t id)
 {
-    H5I_type_t		grp;		/*group the object is in*/
-    H5I_id_group_t	*grp_ptr;	/*ptr to the group	*/
+    H5I_type_t		type;		/*type the object is in*/
+    H5I_id_type_t	*type_ptr;	/*ptr to the type	*/
     H5I_id_info_t	*id_ptr;	/*ptr to the ID		*/
     int ret_value;                      /* Return value */
 
@@ -1237,12 +1552,12 @@ H5I_get_ref(hid_t id)
     assert(id>=0);
 
     /* Check arguments */
-    grp = H5I_GRP(id);
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (!grp_ptr || grp_ptr->count<=0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
+    type = H5I_TYPE(id);
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (!type_ptr || type_ptr->count<=0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
 
     /* General lookup of the ID */
     if (NULL==(id_ptr=H5I_find_id(id)))
@@ -1255,11 +1570,323 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 } /* end H5I_get_ref() */
 
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Iinc_type_ref
+ *
+ * Purpose:	Increments the number of references outstanding for an ID type.
+ *
+ * Return:	Success:	New reference count
+ *		Failure:	Negative
+ *
+ * Programmer:  Nat Furrer
+ *				James Laird
+ *              April 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Iinc_type_ref(H5I_type_t type)
+{
+    int ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Iinc_type_ref, FAIL);
+    H5TRACE1("Is","It",type);
+
+    /* Check arguments */
+    if (type<=0 || type >= H5I_next_type)
+		HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "invalid ID type");
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+    /* Do actual increment operation */
+    if((ret_value = H5I_inc_type_ref(type))<0)
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTINC, FAIL, "can't increment ID type ref count");
+
+done:
+    FUNC_LEAVE_API(ret_value);
+} /* end H5Iinc_ref() */
+
 
 /*-------------------------------------------------------------------------
+ * Function:	H5I_inc_type_ref
+ *
+ * Purpose:	Increment the reference count for an ID type.
+ *
+ * Return:	Success:	The new reference count.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	James Laird
+ *				Nat Furrer
+ *              Friday, April 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5I_inc_type_ref(H5I_type_t type)
+{
+    H5I_id_type_t	*type_ptr;	/* ptr to the type	*/
+    int ret_value;                      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5I_inc_type_ref, FAIL);
+
+    /* Sanity check */
+    assert(type>0 && type < H5I_next_type);
+
+    /* Check arguments */
+    type_ptr = H5I_id_type_list_g[type];
+    if (!type_ptr )
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
+
+    /* Set return value */
+    ret_value=++(type_ptr->count);
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Idec_type_ref
+ *
+ * Purpose:	Decrements the reference count on an entire type of IDs.
+ *		If the type reference count becomes zero then the type is
+ *		destroyed along with all atoms in that type regardless of
+ *		their reference counts.	 Destroying IDs involves calling
+ *		the free-func for each ID's object and then adding the ID
+ *		struct to the ID free list.  Public interface to
+ *		H5I_dec_type_ref.
+ *		Returns the number of references to the type on success; a
+ *		return value of 0 means that the type will have to be
+ *		re-initialized before it can be used again (and should probably
+ *		be set to H5I_UNINIT).
+ *		
+ * Return:	Number of references to type on success/Negative on failure
+ *
+ * Programmer:	Nathaniel Furrer
+ *				James Laird
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t H5Idec_type_ref(H5I_type_t type)
+{
+	herr_t ret_value;
+
+	FUNC_ENTER_API(H5Idec_type_ref, FAIL);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_dec_type_ref(type);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_dec_type_ref
+ *
+ * Purpose:	Decrements the reference count on an entire type of IDs.
+ *		If the type reference count becomes zero then the type is
+ *		destroyed along with all atoms in that type regardless of
+ *		their reference counts.	 Destroying IDs involves calling
+ *		the free-func for each ID's object and then adding the ID
+ *		struct to the ID free list.
+ *		Returns the number of references to the type on success; a
+ *		return value of 0 means that the type will have to be
+ *		re-initialized before it can be used again (and should probably
+ *		be set to H5I_UNINIT).
+ *		
+ * Return:	Number of references to type on success/Negative on failure
+ *
+ * Programmer:	Unknown
+ *
+ * Modifications:
+ *
+ *	Robb Matzke, 25 Feb 1998
+ *	IDs are freed when a type is destroyed.
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5I_dec_type_ref(H5I_type_t type)
+{
+    H5I_id_type_t	*type_ptr = NULL;	/* ptr to the atomic type */
+    herr_t		ret_value = FAIL;
+
+    FUNC_ENTER_NOAPI(H5I_dec_type_ref, FAIL);
+
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number");
+
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
+
+    /*
+     * Decrement the number of users of the atomic type.  If this is the
+     * last user of the type then release all atoms from the type and
+	 * free all memory it used.  The free function is invoked for each atom
+	 * being freed.
+     */
+    if (1==type_ptr->count)
+	{
+		H5I_destroy_type(type);
+		ret_value = 0;
+    }
+	else
+	{
+        --(type_ptr->count);
+		ret_value = type_ptr->count;
+    }
+    
+  done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Iget_type_ref
+ *
+ * Purpose:	Retrieves the number of references outstanding for a type.
+ *
+ * Return:	Success:	Reference count
+ *		Failure:	Negative
+ *
+ * Programmer:  Nat Furrer
+ *				James Laird
+ *              April 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Iget_type_ref(H5I_type_t type)
+{
+    int ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Iget_type_ref, FAIL);
+    H5TRACE1("Is","It",type);
+
+    /* Check arguments */
+    if (type<=0 || type >= H5I_next_type)
+		HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "invalid ID type");
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type");
+	}
+
+    /* Do actual retrieve operation */
+    if((ret_value = H5I_get_type_ref(type))<0)
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTGET, FAIL, "can't get ID type ref count");
+
+done:
+    FUNC_LEAVE_API(ret_value);
+} /* end H5Iget_ref() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5I_get_type_ref
+ *
+ * Purpose:	Retrieve the reference count for an ID type.
+ *
+ * Return:	Success:	The reference count.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:  Nat Furrer
+ *				James Laird
+ *              April 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5I_get_type_ref(H5I_type_t type)
+{
+    H5I_id_type_t	*type_ptr;	/*ptr to the type	*/
+    int ret_value;                      /* Return value */
+
+    FUNC_ENTER_NOAPI(H5I_get_type_ref, FAIL);
+
+    /* Sanity check */
+    assert(type>=0);
+
+    /* Check arguments */
+    type_ptr = H5I_id_type_list_g[type];
+    if (!type_ptr )
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type");
+
+    /* Set return value */
+    ret_value=type_ptr->count;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5I_get_ref() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Isearch
+ *
+ * Purpose:	Apply function FUNC to each member of type TYPE and return a
+ *		pointer to the first object for which FUNC returns non-zero.
+ *		The FUNC should take a pointer to the object and the KEY as
+ *		arguments and return non-zero to terminate the search (zero
+ *		to continue).  Public interface to H5I_search.
+ *
+ * Limitation:	Currently there is no way to start searching from where a
+ *		previous search left off.
+ *
+ * Return:	Success:	The first object in the type for which FUNC
+ *				returns non-zero. NULL if FUNC returned zero
+ *				for every object in the type.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	James Laird
+ *				Nathaniel Furrer
+ *		Friday, April 23, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void *H5Isearch(H5I_type_t type, H5I_search_func_t func, void *key)
+{
+	void * ret_value;                      /* Return value */
+
+    FUNC_ENTER_API(H5Isearch, NULL);
+
+	if( H5I_IS_LIB_TYPE( type ) )
+	{
+		HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "cannot call public function on library type");
+	}
+
+	ret_value = H5I_search(type, func, key);
+
+	done:
+		FUNC_LEAVE_API(ret_value);
+}
+
+/*-------------------------------------------------------------------------
  * Function:	H5I_search
  *
- * Purpose:	Apply function FUNC to each member of group GRP and return a
+ * Purpose:	Apply function FUNC to each member of type TYPE and return a
  *		pointer to the first object for which FUNC returns non-zero.
  *		The FUNC should take a pointer to the object and the KEY as
  *		arguments and return non-zero to terminate the search (zero
@@ -1268,9 +1895,9 @@ done:
  * Limitation:	Currently there is no way to start searching from where a
  *		previous search left off.
  *
- * Return:	Success:	The first object in the group for which FUNC
+ * Return:	Success:	The first object in the type for which FUNC
  *				returns non-zero. NULL if FUNC returned zero
- *				for every object in the group.
+ *				for every object in the type.
  *
  *		Failure:	NULL
  *
@@ -1282,9 +1909,9 @@ done:
  *-------------------------------------------------------------------------
  */
 void *
-H5I_search(H5I_type_t grp, H5I_search_func_t func, void *key)
+H5I_search(H5I_type_t type, H5I_search_func_t func, void *key)
 {
-    H5I_id_group_t	*grp_ptr = NULL;	/*ptr to the group	*/
+    H5I_id_type_t	*type_ptr = NULL;	/*ptr to the type	*/
     H5I_id_info_t	*id_ptr = NULL;		/*ptr to the new ID	*/
     H5I_id_info_t	*next_id = NULL;	/*ptr to the next ID	*/
     unsigned		i;			/*counter		*/
@@ -1293,15 +1920,15 @@ H5I_search(H5I_type_t grp, H5I_search_func_t func, void *key)
     FUNC_ENTER_NOAPI(H5I_search, NULL);
 
     /* Check arguments */
-    if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "invalid group number");
-    grp_ptr = H5I_id_group_list_g[grp];
-    if (grp_ptr == NULL || grp_ptr->count <= 0)
-	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "invalid group");
+    if (type <= H5I_BADID || type >= H5I_next_type)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "invalid type number");
+    type_ptr = H5I_id_type_list_g[type];
+    if (type_ptr == NULL || type_ptr->count <= 0)
+	HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "invalid type");
 
     /* Start at the beginning of the array */
-    for (i=0; i<grp_ptr->hash_size; i++) {
-	id_ptr = grp_ptr->id_list[i];
+    for (i=0; i<type_ptr->hash_size; i++) {
+	id_ptr = type_ptr->id_list[i];
 	while (id_ptr) {
             next_id= id_ptr->next;      /* Protect against ID being deleted in callback */
 	    if ((*func)(id_ptr->obj_ptr, id_ptr->id, key))
@@ -1334,24 +1961,25 @@ done:
 static H5I_id_info_t *
 H5I_find_id(hid_t id)
 {
-    H5I_id_group_t	*grp_ptr;		/*ptr to the group	*/
+    H5I_id_type_t	*type_ptr;		/*ptr to the type	*/
     H5I_id_info_t	*last_id;		/*ptr to the last ID	*/
     H5I_id_info_t	*id_ptr;		/*ptr to the new ID	*/
-    H5I_type_t		grp;			/*ID's group		*/
+    H5I_type_t		type;			/*ID's type		*/
     unsigned		hash_loc;		/*bucket pointer	*/
     H5I_id_info_t	*ret_value = NULL;	/*return value		*/
 
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5I_find_id);
 
     /* Check arguments */
-    grp = H5I_GRP(id);
-    assert(grp > H5I_BADID && grp < H5I_NGROUPS);
-    grp_ptr = H5I_id_group_list_g[grp];
-    assert(grp_ptr && grp_ptr->count > 0);
+    type = H5I_TYPE(id);
+    assert(type > H5I_BADID && type < H5I_next_type);
+    type_ptr = H5I_id_type_list_g[type];
+
+    assert(type_ptr && type_ptr->count > 0);
 
     /* Get the bucket in which the ID is located */
-    hash_loc = (unsigned)H5I_LOC(id, grp_ptr->hash_size);
-    id_ptr = grp_ptr->id_list[hash_loc];
+    hash_loc = (unsigned)H5I_LOC(id, type_ptr->hash_size);
+    id_ptr = type_ptr->id_list[hash_loc];
 
     /* Scan the bucket's linked list for a match */
     last_id=NULL;
@@ -1360,8 +1988,8 @@ H5I_find_id(hid_t id)
             /* If we found an object, move it to the front of the list, if it isn't there already */
             if(last_id!=NULL) {
                 last_id->next=id_ptr->next;
-                id_ptr->next=grp_ptr->id_list[hash_loc];
-                grp_ptr->id_list[hash_loc]=id_ptr;
+                id_ptr->next=type_ptr->id_list[hash_loc];
+                type_ptr->id_list[hash_loc]=id_ptr;
             } /* end if */
             break;
         } /* end if */
@@ -1435,7 +2063,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function: H5I_debug
  *
- * Purpose: Dump the contents of a group to stderr for debugging.
+ * Purpose: Dump the contents of a type to stderr for debugging.
  *
  * Return: Success: Non-negative
  *
@@ -1453,9 +2081,9 @@ done:
  */
 #ifdef H5I_DEBUG_OUTPUT
 static herr_t
-H5I_debug(H5I_type_t grp)
+H5I_debug(H5I_type_t type)
 {
-    H5I_id_group_t *grp_ptr;
+    H5I_id_type_t *type_ptr;
     H5I_id_info_t *cur;
     H5G_entry_t *ent = NULL;
     int   is, js;
@@ -1464,21 +2092,21 @@ H5I_debug(H5I_type_t grp)
 
     FUNC_ENTER_NOAPI(H5I_debug, FAIL);
 
-    fprintf(stderr, "Dumping group %d\n", (int)grp);
-    grp_ptr = H5I_id_group_list_g[grp];
+    fprintf(stderr, "Dumping ID type %d\n", (int)type);
+    type_ptr = H5I_id_type_list_g[type];
 
     /* Header */
-    fprintf(stderr, "	 count	   = %u\n", grp_ptr->count);
-    fprintf(stderr, "	 reserved  = %u\n", grp_ptr->reserved);
-    fprintf(stderr, "	 wrapped   = %u\n", grp_ptr->wrapped);
-    fprintf(stderr, "	 hash_size = %lu\n", (unsigned long)grp_ptr->hash_size);
-    fprintf(stderr, "	 ids	   = %u\n", grp_ptr->ids);
-    fprintf(stderr, "	 nextid	   = %u\n", grp_ptr->nextid);
+    fprintf(stderr, "	 count	   = %u\n", type_ptr->count);
+    fprintf(stderr, "	 reserved  = %u\n", type_ptr->reserved);
+    fprintf(stderr, "	 wrapped   = %u\n", type_ptr->wrapped);
+    fprintf(stderr, "	 hash_size = %lu\n", (unsigned long)type_ptr->hash_size);
+    fprintf(stderr, "	 ids	   = %u\n", type_ptr->ids);
+    fprintf(stderr, "	 nextid	   = %u\n", type_ptr->nextid);
 
     /* Cache */
     fprintf(stderr, "	 Cache:\n");
     for (is=0; is<ID_CACHE_SIZE; is++) {
-        if (H5I_cache_g[is] && H5I_GRP(H5I_cache_g[is]->id)==grp) {
+        if (H5I_cache_g[is] && H5I_TYPE(H5I_cache_g[is]->id)==type) {
             fprintf(stderr, "	     Entry-%d, ID=%lu\n",
                     is, (unsigned long)(H5I_cache_g[is]->id));
         }
@@ -1486,15 +2114,15 @@ H5I_debug(H5I_type_t grp)
 
     /* List */
     fprintf(stderr, "	 List:\n");
-    for (iu=0; iu<grp_ptr->hash_size; iu++) {
-        for (js=0, cur=grp_ptr->id_list[iu]; cur; cur=cur->next, js++) {
+    for (iu=0; iu<type_ptr->hash_size; iu++) {
+        for (js=0, cur=type_ptr->id_list[iu]; cur; cur=cur->next, js++) {
             fprintf(stderr, "	     #%u.%d\n", iu, js);
             fprintf(stderr, "		 id = %lu\n", (unsigned long)(cur->id));
             fprintf(stderr, "		 count = %u\n", cur->count);
             fprintf(stderr, "		 obj   = 0x%08lx\n", (unsigned long)(cur->obj_ptr));
 
             /* Get the symbol table entry, so we get get the name */
-            switch(grp) {
+            switch(type) {
                 case H5I_GROUP:
                     ent = H5G_entof((H5G_t*)cur->obj_ptr);
                     break;