[svn-r9329]

Purpose:
Feature

Description:
Datatypes and groups now use H5FO "file object" code that was previously
only used by datasets.  These objects will hold a file open if the file
is closed but they have not yet been closed.  If these objects are unlinked
then relinked, they will not be destroyed.  If they are opened twice (even
by two different names), both IDs will "see" changes made to the object
using the other ID.
When an object is opened using two different names (e.g., if a dataset was
opened under one name, then mounted and opened under its new name), calling
H5Iget_name() on a given hid_t will return the name used to open that hid_t,
not the current name of the object (this is a feature, and a change from the
previous behavior of datasets).

Solution:
Used H5FO code that was already in place for datasets.  Broke H5D_t's, H5T_t's,
and H5G_t's into a "shared" struct and a private struct.  The shared structs
(H5D_shared_t, etc.) hold the object's information and are used by all IDs
that point to a given object in the file.  The private structs are pointed
to by the hid_t and contain the object's group entry information (including its
name) and a pointer to the shared struct for that object.
This changed the naming of structs throughout the library (e.g., datatype->size
is now datatype->shared->size).  I added an updated H5Tinit.c to windows.zip.

Platforms tested:
Visual Studio 7, sleipnir, arabica, verbena

Misc. update:

1 files changed, 65 insertions, 65 deletions

diff --git a/src/H5Tcompound.c b/src/H5Tcompound.c
index acd82ab..7abcafc 100644
--- a/src/H5Tcompound.c
+++ b/src/H5Tcompound.c
@@ -100,9 +100,9 @@ H5Tget_member_offset(hid_t type_id, unsigned membno)
     H5TRACE2("z","iIu",type_id,membno);
 
     /* Check args */
-    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->type)
+    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->shared->type)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a compound datatype")
-    if (membno >= dt->u.compnd.nmembs)
+    if (membno >= dt->shared->u.compnd.nmembs)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid member number")
 
     /* Value */
@@ -142,10 +142,10 @@ H5T_get_member_offset(const H5T_t *dt, unsigned membno)
     FUNC_ENTER_NOAPI(H5T_get_member_offset, 0)
 
     assert(dt);
-    assert(membno < dt->u.compnd.nmembs);
+    assert(membno < dt->shared->u.compnd.nmembs);
 
     /* Value */
-    ret_value = dt->u.compnd.memb[membno].offset;
+    ret_value = dt->shared->u.compnd.memb[membno].offset;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -186,13 +186,13 @@ H5Tget_member_class(hid_t type_id, unsigned membno)
     H5TRACE2("Tt","iIu",type_id,membno);
 
     /* Check args */
-    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->type)
+    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->shared->type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_NO_CLASS, "not a compound datatype")
-    if (membno >= dt->u.compnd.nmembs)
+    if (membno >= dt->shared->u.compnd.nmembs)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5T_NO_CLASS, "invalid member number")
 
     /* Value */
-    ret_value = dt->u.compnd.memb[membno].type->type;
+    ret_value = dt->shared->u.compnd.memb[membno].type->shared->type;
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -241,9 +241,9 @@ H5Tget_member_type(hid_t type_id, unsigned membno)
     H5TRACE2("i","iIs",type_id,membno);
 
     /* Check args */
-    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->type)
+    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)) || H5T_COMPOUND != dt->shared->type)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound datatype")
-    if (membno >= dt->u.compnd.nmembs)
+    if (membno >= dt->shared->u.compnd.nmembs)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number")
     if ((memb_dt=H5T_get_member_type(dt, membno))==NULL)
 	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to retrieve member type")
@@ -289,10 +289,10 @@ H5T_get_member_type(const H5T_t *dt, unsigned membno)
     FUNC_ENTER_NOAPI(H5T_get_member_type, NULL)
 
     assert(dt);
-    assert(membno < dt->u.compnd.nmembs);
+    assert(membno < dt->shared->u.compnd.nmembs);
     
     /* Copy datatype into an atom */
-    if (NULL == (ret_value = H5T_copy(dt->u.compnd.memb[membno].type, H5T_COPY_REOPEN)))
+    if (NULL == (ret_value = H5T_copy(dt->shared->u.compnd.memb[membno].type, H5T_COPY_REOPEN)))
 	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to copy member datatype")
     
 done:
@@ -337,9 +337,9 @@ H5Tinsert(hid_t parent_id, const char *name, size_t offset, hid_t member_id)
     /* Check args */
     if (parent_id==member_id)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "can't insert compound datatype within itself")
-    if (NULL == (parent = H5I_object_verify(parent_id,H5I_DATATYPE)) || H5T_COMPOUND != parent->type)
+    if (NULL == (parent = H5I_object_verify(parent_id,H5I_DATATYPE)) || H5T_COMPOUND != parent->shared->type)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound datatype")
-    if (H5T_STATE_TRANSIENT!=parent->state)
+    if (H5T_STATE_TRANSIENT!=parent->shared->state)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "parent type read-only")
     if (!name || !*name)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no member name")
@@ -420,82 +420,82 @@ H5T_insert(H5T_t *parent, const char *name, size_t offset, const H5T_t *member)
     FUNC_ENTER_NOAPI(H5T_insert, FAIL)
 
     /* check args */
-    assert(parent && H5T_COMPOUND == parent->type);
-    assert(H5T_STATE_TRANSIENT==parent->state);
+    assert(parent && H5T_COMPOUND == parent->shared->type);
+    assert(H5T_STATE_TRANSIENT==parent->shared->state);
     assert(member);
     assert(name && *name);
 
     /* Does NAME already exist in PARENT? */
-    for (i=0; i<parent->u.compnd.nmembs; i++) {
-	if (!HDstrcmp(parent->u.compnd.memb[i].name, name))
+    for (i=0; i<parent->shared->u.compnd.nmembs; i++) {
+	if (!HDstrcmp(parent->shared->u.compnd.memb[i].name, name))
 	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL, "member name is not unique")
     }
 
     /* Does the new member overlap any existing member ? */
-    total_size=member->size;
-    for (i=0; i<parent->u.compnd.nmembs; i++) {
-	if ((offset <= parent->u.compnd.memb[i].offset &&
-                 offset + total_size > parent->u.compnd.memb[i].offset) ||
-                (parent->u.compnd.memb[i].offset <= offset &&
-                 parent->u.compnd.memb[i].offset +
-                 parent->u.compnd.memb[i].size > offset))
+    total_size=member->shared->size;
+    for (i=0; i<parent->shared->u.compnd.nmembs; i++) {
+	if ((offset <= parent->shared->u.compnd.memb[i].offset &&
+                 offset + total_size > parent->shared->u.compnd.memb[i].offset) ||
+                (parent->shared->u.compnd.memb[i].offset <= offset &&
+                 parent->shared->u.compnd.memb[i].offset +
+                 parent->shared->u.compnd.memb[i].size > offset))
 	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL, "member overlaps with another member")
     }
 
     /* Does the new member overlap the end of the compound type? */
-    if(offset+total_size>parent->size)
+    if(offset+total_size>parent->shared->size)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL, "member extends past end of compound type")
 
     /* Increase member array if necessary */
-    if (parent->u.compnd.nmembs >= parent->u.compnd.nalloc) {
-        size_t na = parent->u.compnd.nalloc + H5T_COMPND_INC;
-        H5T_cmemb_t *x = H5MM_realloc (parent->u.compnd.memb,
+    if (parent->shared->u.compnd.nmembs >= parent->shared->u.compnd.nalloc) {
+        size_t na = parent->shared->u.compnd.nalloc + H5T_COMPND_INC;
+        H5T_cmemb_t *x = H5MM_realloc (parent->shared->u.compnd.memb,
                            na * sizeof(H5T_cmemb_t));
 
         if (!x)
             HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-        parent->u.compnd.nalloc = na;
-        parent->u.compnd.memb = x;
+        parent->shared->u.compnd.nalloc = na;
+        parent->shared->u.compnd.memb = x;
     }
 
     /* Add member to end of member array */
-    idx = parent->u.compnd.nmembs;
-    parent->u.compnd.memb[idx].name = H5MM_xstrdup(name);
-    parent->u.compnd.memb[idx].offset = offset;
-    parent->u.compnd.memb[idx].size = total_size;
-    parent->u.compnd.memb[idx].type = H5T_copy (member, H5T_COPY_ALL);
+    idx = parent->shared->u.compnd.nmembs;
+    parent->shared->u.compnd.memb[idx].name = H5MM_xstrdup(name);
+    parent->shared->u.compnd.memb[idx].offset = offset;
+    parent->shared->u.compnd.memb[idx].size = total_size;
+    parent->shared->u.compnd.memb[idx].type = H5T_copy (member, H5T_COPY_ALL);
 
-    parent->u.compnd.sorted = H5T_SORT_NONE;
-    parent->u.compnd.nmembs++;
+    parent->shared->u.compnd.sorted = H5T_SORT_NONE;
+    parent->shared->u.compnd.nmembs++;
 
     /* Determine if the compound datatype stayed packed */
-    if(parent->u.compnd.packed) {
+    if(parent->shared->u.compnd.packed) {
         /* Check if the member type is packed */
-        if(H5T_is_packed(parent->u.compnd.memb[idx].type)>0) {
+        if(H5T_is_packed(parent->shared->u.compnd.memb[idx].type)>0) {
             if(idx==0) {
                 /* If the is the first member, the datatype is not packed
                  * if the first member isn't at offset 0
                  */
-                if(parent->u.compnd.memb[idx].offset>0)
-                    parent->u.compnd.packed=FALSE;
+                if(parent->shared->u.compnd.memb[idx].offset>0)
+                    parent->shared->u.compnd.packed=FALSE;
             } /* end if */
             else {
                 /* If the is not the first member, the datatype is not
                  * packed if the new member isn't adjoining the previous member
                  */
-                if(parent->u.compnd.memb[idx].offset!=(parent->u.compnd.memb[idx-1].offset+parent->u.compnd.memb[idx-1].size))
-                    parent->u.compnd.packed=FALSE;
+                if(parent->shared->u.compnd.memb[idx].offset!=(parent->shared->u.compnd.memb[idx-1].offset+parent->shared->u.compnd.memb[idx-1].size))
+                    parent->shared->u.compnd.packed=FALSE;
             } /* end else */
         } /* end if */
         else
-            parent->u.compnd.packed=FALSE;
+            parent->shared->u.compnd.packed=FALSE;
     } /* end if */
 
     /*
      * Set the "force conversion" flag if the field's datatype indicates
      */
-    if(member->force_conv==TRUE)
-        parent->force_conv=TRUE;
+    if(member->shared->force_conv==TRUE)
+        parent->shared->force_conv=TRUE;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -534,38 +534,38 @@ H5T_pack(H5T_t *dt)
             HGOTO_DONE(SUCCEED);
 
         /* Check for packing unmodifiable datatype */
-        if (H5T_STATE_TRANSIENT!=dt->state)
+        if (H5T_STATE_TRANSIENT!=dt->shared->state)
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "datatype is read-only")
 
-        if(dt->parent) {
-            if (H5T_pack(dt->parent) < 0)
+        if(dt->shared->parent) {
+            if (H5T_pack(dt->shared->parent) < 0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to pack parent of datatype")
 
             /* Adjust size of datatype appropriately */
-            if(dt->type==H5T_ARRAY)
-                dt->size = dt->parent->size * dt->u.array.nelem;
-            else if(dt->type!=H5T_VLEN)
-                dt->size = dt->parent->size;
+            if(dt->shared->type==H5T_ARRAY)
+                dt->shared->size = dt->shared->parent->shared->size * dt->shared->u.array.nelem;
+            else if(dt->shared->type!=H5T_VLEN)
+                dt->shared->size = dt->shared->parent->shared->size;
         } /* end if */
-        else if(dt->type==H5T_COMPOUND) {
+        else if(dt->shared->type==H5T_COMPOUND) {
             /* Recursively pack the members */
-            for (i=0; i<dt->u.compnd.nmembs; i++)
-                if (H5T_pack(dt->u.compnd.memb[i].type) < 0)
+            for (i=0; i<dt->shared->u.compnd.nmembs; i++)
+                if (H5T_pack(dt->shared->u.compnd.memb[i].type) < 0)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to pack part of a compound datatype")
 
             /* Remove padding between members */
             if(H5T_sort_value(dt, NULL)<0)
 		HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOMPARE, FAIL, "value sort failed")
-            for (i=0, offset=0; i<dt->u.compnd.nmembs; i++) {
-                dt->u.compnd.memb[i].offset = offset;
-                offset += dt->u.compnd.memb[i].size;
+            for (i=0, offset=0; i<dt->shared->u.compnd.nmembs; i++) {
+                dt->shared->u.compnd.memb[i].offset = offset;
+                offset += dt->shared->u.compnd.memb[i].size;
             }
 
             /* Change total size */
-            dt->size = MAX(1, offset);
+            dt->shared->size = MAX(1, offset);
 
             /* Mark the type as packed now */
-            dt->u.compnd.packed=TRUE;
+            dt->shared->u.compnd.packed=TRUE;
         } /* end if */
     } /* end if */
     
@@ -599,12 +599,12 @@ H5T_is_packed(const H5T_t *dt)
     assert(dt);
 
     /* Go up the chain as far as possible */
-    while(dt->parent)
-        dt=dt->parent;
+    while(dt->shared->parent)
+        dt=dt->shared->parent;
 
     /* If this is a compound datatype, check if it is packed */
-    if(dt->type==H5T_COMPOUND)
-        ret_value=(htri_t)dt->u.compnd.packed;
+    if(dt->shared->type==H5T_COMPOUND)
+        ret_value=(htri_t)dt->shared->u.compnd.packed;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)