2003-02-17 23:54:15 +08:00
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
2007-02-07 22:56:24 +08:00
|
|
|
|
* Copyright by The HDF Group. *
|
2003-02-17 23:54:15 +08:00
|
|
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
|
|
|
* All rights reserved. *
|
|
|
|
|
* *
|
|
|
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
|
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
|
|
|
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
|
|
|
|
* of the source code distribution tree; Copyright.html can be found at the *
|
|
|
|
|
* root level of an installed copy of the electronic HDF5 document set and *
|
|
|
|
|
* is linked from the top-level documents page. It can also be found at *
|
2007-02-07 22:56:24 +08:00
|
|
|
|
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
|
|
|
|
|
* access to either file, you may request a copy from help@hdfgroup.org. *
|
2003-02-17 23:54:15 +08:00
|
|
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
|
|
1997-07-31 05:17:56 +08:00
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
*
|
1998-03-25 07:18:34 +08:00
|
|
|
|
* Created: H5G.c
|
|
|
|
|
* Jul 18 1997
|
|
|
|
|
* Robb Matzke <matzke@llnl.gov>
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Symbol table functions. The functions that begin with
|
|
|
|
|
* `H5G_stab_' don't understand the naming system; they operate
|
|
|
|
|
* on a single symbol table at a time.
|
|
|
|
|
*
|
|
|
|
|
* The functions that begin with `H5G_node_' operate on the leaf
|
|
|
|
|
* nodes of a symbol table B-tree. They should be defined in
|
2005-08-14 04:53:35 +08:00
|
|
|
|
* the H5Gnode.c file.
|
1998-03-25 07:18:34 +08:00
|
|
|
|
*
|
|
|
|
|
* The remaining functions know how to traverse the group
|
|
|
|
|
* directed graph.
|
|
|
|
|
*
|
|
|
|
|
* Names: Object names are a slash-separated list of components. If
|
|
|
|
|
* the name begins with a slash then it's absolute, otherwise
|
|
|
|
|
* it's relative ("/foo/bar" is absolute while "foo/bar" is
|
|
|
|
|
* relative). Multiple consecutive slashes are treated as
|
|
|
|
|
* single slashes and trailing slashes are ignored. The special
|
|
|
|
|
* case `/' is the root group. Every file has a root group.
|
|
|
|
|
*
|
|
|
|
|
* API functions that look up names take a location ID and a
|
|
|
|
|
* name. The location ID can be a file ID or a group ID and the
|
|
|
|
|
* name can be relative or absolute.
|
|
|
|
|
*
|
|
|
|
|
* +--------------+----------- +--------------------------------+
|
|
|
|
|
* | Location ID | Name | Meaning |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | File ID | "/foo/bar" | Find `foo' within `bar' within |
|
|
|
|
|
* | | | the root group of the specified|
|
|
|
|
|
* | | | file. |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | File ID | "foo/bar" | Find `foo' within `bar' within |
|
2006-10-02 18:24:03 +08:00
|
|
|
|
* | | | the root group of the specified|
|
|
|
|
|
* | | | file. |
|
1998-03-25 07:18:34 +08:00
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | File ID | "/" | The root group of the specified|
|
|
|
|
|
* | | | file. |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
2006-10-02 18:24:03 +08:00
|
|
|
|
* | File ID | "." | The root group of the specified|
|
1998-03-25 07:18:34 +08:00
|
|
|
|
* | | | the specified file. |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | Group ID | "/foo/bar" | Find `foo' within `bar' within |
|
|
|
|
|
* | | | the root group of the file |
|
|
|
|
|
* | | | containing the specified group.|
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | Group ID | "foo/bar" | File `foo' within `bar' within |
|
|
|
|
|
* | | | the specified group. |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | Group ID | "/" | The root group of the file |
|
|
|
|
|
* | | | containing the specified group.|
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
|
|
|
|
* | Group ID | "." | The specified group. |
|
|
|
|
|
* +--------------+------------+--------------------------------+
|
1997-07-31 05:17:56 +08:00
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2000-10-10 15:43:38 +08:00
|
|
|
|
|
2005-09-12 22:29:54 +08:00
|
|
|
|
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
#define H5G_PACKAGE /*suppress error about including H5Gpkg */
|
2000-10-10 15:43:38 +08:00
|
|
|
|
|
2004-06-23 23:36:35 +08:00
|
|
|
|
/* Interface initialization */
|
|
|
|
|
#define H5_INTERFACE_INIT_FUNC H5G_init_interface
|
|
|
|
|
|
1997-07-31 05:17:56 +08:00
|
|
|
|
/* Packages needed by this file... */
|
2003-05-09 04:09:07 +08:00
|
|
|
|
#include "H5private.h" /* Generic Functions */
|
|
|
|
|
#include "H5Eprivate.h" /* Error handling */
|
|
|
|
|
#include "H5Fpkg.h" /* File access */
|
|
|
|
|
#include "H5Gpkg.h" /* Groups */
|
|
|
|
|
#include "H5Iprivate.h" /* IDs */
|
2007-04-12 00:22:16 +08:00
|
|
|
|
#include "H5Lprivate.h" /* Links */
|
2005-06-21 02:11:57 +08:00
|
|
|
|
#include "H5Pprivate.h" /* Property lists */
|
1997-08-08 03:23:00 +08:00
|
|
|
|
|
2003-05-16 03:22:33 +08:00
|
|
|
|
/* Local macros */
|
1998-01-28 13:47:19 +08:00
|
|
|
|
#define H5G_RESERVED_ATOMS 0
|
2003-05-16 03:22:33 +08:00
|
|
|
|
|
|
|
|
|
/* Local typedefs */
|
1997-09-22 10:08:54 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* User data for path traversal routine for "insertion file" routine */
|
|
|
|
|
typedef struct {
|
2006-08-19 04:48:54 +08:00
|
|
|
|
H5G_loc_t *loc; /* Pointer to the location for insertion */
|
2006-11-25 12:10:32 +08:00
|
|
|
|
} H5G_trav_ins_t;
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
2005-11-07 11:13:53 +08:00
|
|
|
|
/* Package variables */
|
|
|
|
|
|
2003-05-16 03:22:33 +08:00
|
|
|
|
/* Local variables */
|
[svn-r6252] Purpose:
Lots of performance improvements & a couple new internal API interfaces.
Description:
Performance Improvements:
- Cached file offset & length sizes in shared file struct, to avoid
constantly looking them up in the FCPL.
- Generic property improvements:
- Added "revision" number to generic property classes to speed
up comparisons.
- Changed method of storing properties from using a hash-table
to the TBBT routines in the library.
- Share the propery names between classes and the lists derived
from them.
- Removed redundant 'def_value' buffer from each property.
- Switching code to use a "copy on write" strategy for
properties in each list, where the properties in each list
are shared with the properties in the class, until a
property's value is changed in a list.
- Fixed error in layout code which was allocating too many buffers.
- Redefined public macros of the form (H5open()/H5check, <variable>)
internally to only be (<variable>), avoiding innumerable useless
calls to H5open() and H5check_version().
- Reuse already zeroed buffers in H5F_contig_fill instead of
constantly re-zeroing them.
- Don't write fill values if writing entire dataset.
- Use gettimeofday() system call instead of time() system when
checking the modification time of a dataset.
- Added reference counted string API and use it for tracking the
names of objects opening in a file (for the ID->name code).
- Removed redundant H5P_get() calls in B-tree routines.
- Redefine H5T datatype macros internally to the library, to avoid
calling H5check redundantly.
- Keep dataspace information for dataset locally instead of reading
from disk each time. Added new module to track open objects
in a file, to allow this (which will be useful eventually for
some FPH5 metadata caching issues).
- Remove H5AC_find macro which was inlining metadata cache lookups,
and call function instead.
- Remove redundant memset() calls from H5G_namei() routine.
- Remove redundant checking of object type when locating objects
in metadata cache and rely on the address only.
- Create default dataset object to use when default dataset creation
property list is used to create datasets, bypassing querying
for all the property list values.
- Use default I/O vector size when performing raw data with the
default dataset transfer property list, instead of querying for
I/O vector size.
- Remove H5P_DEFAULT internally to the library, replacing it with
more specific default property list based on the type of
property list needed.
- Remove redundant memset() calls in object header message (H5O*)
routines.
- Remove redunant memset() calls in data I/O routines.
- Split free-list allocation routines into malloc() and calloc()-
like routines, instead of one combined routine.
- Remove lots of indirection in H5O*() routines.
- Simplify metadata cache entry comparison routine (used when
flushing entire cache out).
- Only enable metadata cache statistics when H5AC_DEBUG is turned
on, instead of always tracking them.
- Simplify address comparison macro (H5F_addr_eq).
- Remove redundant metadata cache entry protections during dataset
creation by protecting the object header once and making all
the modifications necessary for the dataset creation before
unprotecting it.
- Reduce # of "number of element in extent" computations performed
by computing and storing the value during dataspace creation.
- Simplify checking for group location's file information, when file
has not been involving in file-mounting operations.
- Use binary encoding for modification time, instead of ASCII.
- Hoist H5HL_peek calls (to get information in a local heap)
out of loops in many group routine.
- Use static variable for iterators of selections, instead of
dynamically allocation them each time.
- Lookup & insert new entries in one step, avoiding traversing
group's B-tree twice.
- Fixed memory leak in H5Gget_objname_idx() routine (tangential to
performance improvements, but fixed along the way).
- Use free-list for reference counted strings.
- Don't bother copying object names into cached group entries,
since they are re-created when an object is opened.
The benchmark I used to measure these results created several thousand
small (2K) datasets in a file and wrote out the data for them. This is
Elena's "regular.c" benchmark.
These changes resulted in approximately ~4.3x speedup of the
development branch when compared to the previous code in the
development branch and ~1.4x speedup compared to the release
branch.
Additionally, these changes reduce the total memory used (code and
data) by the development branch by ~800KB, bringing the development
branch back into the same ballpark as the release branch.
I'll send out a more detailed description of the benchmark results
as a followup note.
New internal API routines:
Added "reference counted strings" API for tracking strings that get
used by multiple owners without duplicating the strings.
Added "ternary search tree" API for text->object mappings.
Platforms tested:
Tested h5committest {arabica (fortran), eirene (fortran, C++)
modi4 (parallel, fortran)}
Other platforms/configurations tested?
FreeBSD 4.7 (sleipnir) serial & parallel
Solaris 2.6 (baldric) serial
2003-01-10 01:20:03 +08:00
|
|
|
|
|
2000-08-17 04:13:02 +08:00
|
|
|
|
/* Declare a free list to manage the H5G_t struct */
|
|
|
|
|
H5FL_DEFINE(H5G_t);
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
H5FL_DEFINE(H5G_shared_t);
|
2000-08-17 04:13:02 +08:00
|
|
|
|
|
2002-08-29 02:34:12 +08:00
|
|
|
|
/* Private prototypes */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
static herr_t H5G_open_oid(H5G_t *grp, hid_t dxpl_id);
|
2002-08-29 02:34:12 +08:00
|
|
|
|
|
1997-10-21 07:14:35 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Function: H5Gcreate2
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Purpose: Creates a new group relative to LOC_ID, giving it the
|
|
|
|
|
* specified creation property list GCPL_ID and access
|
|
|
|
|
* property list GAPL_ID. The link to the new group is
|
|
|
|
|
* created with the LCPL_ID.
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Usage: H5Gcreate2(loc_id, char *name, lcpl_id, gcpl_id, gapl_id)
|
|
|
|
|
* hid_t loc_id; IN: File or group identifier
|
|
|
|
|
* const char *name; IN: Absolute or relative name of the new group
|
|
|
|
|
* hid_t lcpl_id; IN: Property list for link creation
|
|
|
|
|
* hid_t gcpl_id; IN: Property list for group creation
|
|
|
|
|
* hid_t gapl_id; IN: Property list for group access
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Return: Success: The object ID of a new, empty group open for
|
|
|
|
|
* writing. Call H5Gclose() when finished with
|
|
|
|
|
* the group.
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* April 5, 2007
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
1998-01-06 11:07:15 +08:00
|
|
|
|
hid_t
|
2007-04-12 00:22:16 +08:00
|
|
|
|
H5Gcreate2(hid_t loc_id, const char *name, hid_t lcpl_id, hid_t gcpl_id,
|
|
|
|
|
hid_t gapl_id)
|
1997-10-21 07:14:35 +08:00
|
|
|
|
{
|
2007-04-12 00:22:16 +08:00
|
|
|
|
H5G_loc_t loc; /* Location to create group */
|
|
|
|
|
H5G_t *grp = NULL; /* New group created */
|
|
|
|
|
hid_t ret_value; /* Return value */
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gcreate2, FAIL)
|
2007-04-19 04:15:58 +08:00
|
|
|
|
H5TRACE5("i", "i*siii", loc_id, name, lcpl_id, gcpl_id, gapl_id);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Check arguments */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5G_loc(loc_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
|
|
|
|
if(!name || !*name)
|
2007-04-12 00:22:16 +08:00
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Get correct property list */
|
|
|
|
|
if(H5P_DEFAULT == lcpl_id)
|
|
|
|
|
lcpl_id = H5P_LINK_CREATE_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(lcpl_id, H5P_LINK_CREATE))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not link creation property list")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Check group creation property list */
|
|
|
|
|
if(H5P_DEFAULT == gcpl_id)
|
|
|
|
|
gcpl_id = H5P_GROUP_CREATE_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(gcpl_id, H5P_GROUP_CREATE))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not group create property list")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Check the group access property list */
|
|
|
|
|
if(H5P_DEFAULT == gapl_id)
|
|
|
|
|
gapl_id = H5P_GROUP_ACCESS_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(gapl_id, H5P_GROUP_ACCESS))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not group access property list")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Create the new group & get its ID */
|
|
|
|
|
if(NULL == (grp = H5G_create_named(&loc, name, lcpl_id, gcpl_id, gapl_id, H5AC_dxpl_id)))
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group")
|
|
|
|
|
if((ret_value = H5I_register(H5I_GROUP, grp)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
done:
|
|
|
|
|
if(ret_value < 0)
|
|
|
|
|
if(grp && H5G_close(grp) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gcreate2() */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_create_named
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Internal routine to create a new "named" group.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Non-NULL, pointer to new group object.
|
|
|
|
|
*
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* April 5, 2007
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
H5G_t *
|
|
|
|
|
H5G_create_named(const H5G_loc_t *loc, const char *name, hid_t lcpl_id,
|
|
|
|
|
hid_t gcpl_id, hid_t gapl_id, hid_t dxpl_id)
|
|
|
|
|
{
|
|
|
|
|
H5O_obj_create_t ocrt_info; /* Information for object creation */
|
|
|
|
|
H5G_obj_create_t gcrt_info; /* Information for group creation */
|
|
|
|
|
H5G_t *ret_value; /* Return value */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_create_named, NULL)
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Check arguments */
|
|
|
|
|
HDassert(loc);
|
|
|
|
|
HDassert(name && *name);
|
|
|
|
|
HDassert(lcpl_id != H5P_DEFAULT);
|
|
|
|
|
HDassert(gcpl_id != H5P_DEFAULT);
|
|
|
|
|
HDassert(gapl_id != H5P_DEFAULT);
|
|
|
|
|
HDassert(dxpl_id != H5P_DEFAULT);
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Set up group creation info */
|
|
|
|
|
gcrt_info.gcpl_id = gcpl_id;
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Set up object creation information */
|
|
|
|
|
ocrt_info.obj_type = H5O_TYPE_GROUP;
|
|
|
|
|
ocrt_info.crt_info = &gcrt_info;
|
|
|
|
|
ocrt_info.new_obj = NULL;
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Create the new group and link it to its parent group */
|
|
|
|
|
if(H5L_link_object(loc, name, &ocrt_info, lcpl_id, gapl_id, dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "unable to create and link to group")
|
|
|
|
|
HDassert(ocrt_info.new_obj);
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
/* Set the return value */
|
|
|
|
|
ret_value = ocrt_info.new_obj;
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_create_named() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2005-06-21 02:11:57 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Function: H5Gcreate_anon
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
2006-07-06 03:01:50 +08:00
|
|
|
|
* Purpose: Creates a new group relative to LOC_ID, giving it the
|
|
|
|
|
* specified creation property list GCPL_ID and access
|
2005-08-14 04:53:35 +08:00
|
|
|
|
* property list GAPL_ID.
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
2006-07-06 03:01:50 +08:00
|
|
|
|
* The resulting ID should be linked into the file with
|
[svn-r14228] Description:
Change H5Llink to H5Olink, which makes more sense.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-11-02 01:32:49 +08:00
|
|
|
|
* H5Olink or it will be deleted when closed.
|
2006-07-06 03:01:50 +08:00
|
|
|
|
*
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Given the default setting, H5Gcreate_anon() followed by
|
[svn-r14228] Description:
Change H5Llink to H5Olink, which makes more sense.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-11-02 01:32:49 +08:00
|
|
|
|
* H5Olink() will have the same function as H5Gcreate2().
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Usage: H5Gcreate_anon(loc_id, char *name, gcpl_id, gapl_id)
|
|
|
|
|
* hid_t loc_id; IN: File or group identifier
|
|
|
|
|
* const char *name; IN: Absolute or relative name of the new group
|
|
|
|
|
* hid_t gcpl_id; IN: Property list for group creation
|
|
|
|
|
* hid_t gapl_id; IN: Property list for group access
|
2006-04-02 04:14:11 +08:00
|
|
|
|
*
|
|
|
|
|
* Example: To create missing groups "A" and "B01" along the given path "/A/B01/grp"
|
|
|
|
|
* hid_t create_id = H5Pcreate(H5P_GROUP_CREATE);
|
|
|
|
|
* int status = H5Pset_create_intermediate_group(create_id, TRUE);
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* hid_t gid = H5Gcreate_anon(file_id, "/A/B01/grp", create_id, H5P_DEFAULT);
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
|
|
|
|
* Return: Success: The object ID of a new, empty group open for
|
|
|
|
|
* writing. Call H5Gclose() when finished with
|
|
|
|
|
* the group.
|
|
|
|
|
*
|
|
|
|
|
* Failure: FAIL
|
|
|
|
|
*
|
2005-08-14 04:53:35 +08:00
|
|
|
|
* Programmer: Peter Cao
|
|
|
|
|
* May 08, 2005
|
2007-04-12 00:22:16 +08:00
|
|
|
|
*
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
2007-04-12 00:22:16 +08:00
|
|
|
|
H5Gcreate_anon(hid_t loc_id, hid_t gcpl_id, hid_t gapl_id)
|
2005-06-21 02:11:57 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_loc_t loc;
|
|
|
|
|
H5G_t *grp = NULL;
|
|
|
|
|
hid_t ret_value;
|
2005-06-21 02:11:57 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gcreate_anon, FAIL)
|
2006-12-19 03:16:17 +08:00
|
|
|
|
H5TRACE3("i", "iii", loc_id, gcpl_id, gapl_id);
|
2005-06-21 02:11:57 +08:00
|
|
|
|
|
|
|
|
|
/* Check arguments */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5G_loc(loc_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-06-21 02:11:57 +08:00
|
|
|
|
/* Check group creation property list */
|
|
|
|
|
if(H5P_DEFAULT == gcpl_id)
|
|
|
|
|
gcpl_id = H5P_GROUP_CREATE_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(gcpl_id, H5P_GROUP_CREATE))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not group create property list")
|
|
|
|
|
|
|
|
|
|
/* Check the group access property list */
|
|
|
|
|
if(H5P_DEFAULT == gapl_id)
|
|
|
|
|
gapl_id = H5P_GROUP_ACCESS_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(gapl_id, H5P_GROUP_ACCESS))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not group access property list")
|
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Create the new group & get its ID */
|
2007-04-12 00:22:16 +08:00
|
|
|
|
if(NULL == (grp = H5G_create(loc.oloc->file, gcpl_id, H5AC_dxpl_id)))
|
2005-06-21 02:11:57 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if((ret_value = H5I_register(H5I_GROUP, grp)) < 0)
|
2005-06-21 02:11:57 +08:00
|
|
|
|
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
|
|
|
|
|
|
|
|
|
|
done:
|
2007-04-12 00:22:16 +08:00
|
|
|
|
if(ret_value < 0)
|
|
|
|
|
if(grp && H5G_close(grp) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group")
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
2007-04-12 00:22:16 +08:00
|
|
|
|
} /* end H5Gcreate_anon() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2007-04-12 00:22:16 +08:00
|
|
|
|
* Function: H5Gopen2
|
2006-08-03 07:41:53 +08:00
|
|
|
|
*
|
|
|
|
|
* Purpose: Opens an existing group for modification. When finished,
|
|
|
|
|
* call H5Gclose() to close it and release resources.
|
|
|
|
|
*
|
|
|
|
|
* This function allows the user the pass in a Group Access
|
2007-08-28 23:02:54 +08:00
|
|
|
|
* Property List, which H5Gopen1() does not.
|
2006-08-03 07:41:53 +08:00
|
|
|
|
*
|
|
|
|
|
* Return: Success: Object ID of the group.
|
|
|
|
|
* Failure: FAIL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: James Laird
|
|
|
|
|
* Thursday, July 27, 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
2007-04-12 00:22:16 +08:00
|
|
|
|
H5Gopen2(hid_t loc_id, const char *name, hid_t gapl_id)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
{
|
2007-08-28 23:02:54 +08:00
|
|
|
|
H5G_t *grp = NULL; /* Group opened */
|
|
|
|
|
H5G_loc_t loc; /* Location of parent for group */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
hid_t ret_value; /* Return value */
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gopen2, FAIL)
|
2007-03-09 00:57:36 +08:00
|
|
|
|
H5TRACE3("i", "i*si", loc_id, name, gapl_id);
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(H5G_loc(loc_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
|
|
|
|
if(!name || !*name)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
|
|
|
|
|
|
|
|
|
|
/* Check the group access property list */
|
|
|
|
|
if(H5P_DEFAULT == gapl_id)
|
|
|
|
|
gapl_id = H5P_GROUP_ACCESS_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(gapl_id, H5P_GROUP_ACCESS))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not group access property list")
|
|
|
|
|
|
|
|
|
|
/* Open the group */
|
2007-08-28 23:02:54 +08:00
|
|
|
|
if((grp = H5G_open_name(&loc, name, gapl_id, H5AC_dxpl_id)) == NULL)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group")
|
|
|
|
|
|
|
|
|
|
/* Register an atom for the group */
|
|
|
|
|
if((ret_value = H5I_register(H5I_GROUP, grp)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
if(ret_value < 0) {
|
2007-08-28 23:02:54 +08:00
|
|
|
|
if(grp && H5G_close(grp) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group")
|
2006-08-03 07:41:53 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
2007-04-12 00:22:16 +08:00
|
|
|
|
} /* end H5Gopen2() */
|
2002-11-26 01:59:14 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gget_create_plist
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Returns a copy of the group creation property list.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: ID for a copy of the group creation
|
|
|
|
|
* property list. The property list ID should be
|
|
|
|
|
* released by calling H5Pclose().
|
|
|
|
|
*
|
|
|
|
|
* Failure: FAIL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Tuesday, October 25, 2005
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
|
|
|
|
H5Gget_create_plist(hid_t group_id)
|
|
|
|
|
{
|
|
|
|
|
htri_t ginfo_exists = 0;
|
2006-10-30 22:33:14 +08:00
|
|
|
|
htri_t linfo_exists = 0;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_t *grp = NULL;
|
|
|
|
|
H5P_genplist_t *gcpl_plist;
|
|
|
|
|
H5P_genplist_t *new_plist;
|
|
|
|
|
hid_t new_gcpl_id = FAIL;
|
|
|
|
|
hid_t ret_value = FAIL;
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gget_create_plist, FAIL)
|
2006-12-19 03:16:17 +08:00
|
|
|
|
H5TRACE1("i", "i", group_id);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(NULL == (grp = H5I_object_verify(group_id, H5I_GROUP)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a group")
|
|
|
|
|
|
|
|
|
|
/* Copy the default group creation property list */
|
|
|
|
|
if(NULL == (gcpl_plist = H5I_object(H5P_LST_GROUP_CREATE_g)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "can't get default group creation property list")
|
|
|
|
|
if((new_gcpl_id = H5P_copy_plist(gcpl_plist)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to copy the creation property list")
|
|
|
|
|
if(NULL == (new_plist = H5I_object(new_gcpl_id)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "can't get property list")
|
|
|
|
|
|
2006-11-29 12:13:02 +08:00
|
|
|
|
/* Retrieve any object creation properties */
|
|
|
|
|
if(H5O_get_create_plist(&grp->oloc, H5AC_ind_dxpl_id, new_plist) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't get object creation info")
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Check for the group having a group info message */
|
2007-02-06 06:26:44 +08:00
|
|
|
|
if((ginfo_exists = H5O_msg_exists(&(grp->oloc), H5O_GINFO_ID, H5AC_ind_dxpl_id)) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
|
|
|
|
|
if(ginfo_exists) {
|
|
|
|
|
H5O_ginfo_t ginfo; /* Group info message */
|
|
|
|
|
|
|
|
|
|
/* Read the group info */
|
2007-02-06 06:26:44 +08:00
|
|
|
|
if(NULL == H5O_msg_read(&(grp->oloc), H5O_GINFO_ID, &ginfo, H5AC_ind_dxpl_id))
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_BADMESG, FAIL, "can't get group info")
|
|
|
|
|
|
|
|
|
|
/* Set the group info for the property list */
|
|
|
|
|
if(H5P_set(new_plist, H5G_CRT_GROUP_INFO_NAME, &ginfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set group info")
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
2006-10-30 22:33:14 +08:00
|
|
|
|
/* Check for the group having a link info message */
|
2007-02-06 06:26:44 +08:00
|
|
|
|
if((linfo_exists = H5O_msg_exists(&(grp->oloc), H5O_LINFO_ID, H5AC_ind_dxpl_id)) < 0)
|
2006-10-30 22:33:14 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
|
|
|
|
|
if(linfo_exists) {
|
|
|
|
|
H5O_linfo_t linfo; /* Link info message */
|
|
|
|
|
|
|
|
|
|
/* Read the link info */
|
2007-03-12 10:38:08 +08:00
|
|
|
|
if(NULL == H5G_obj_get_linfo(&(grp->oloc), &linfo, H5AC_ind_dxpl_id))
|
2006-10-30 22:33:14 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info")
|
|
|
|
|
|
|
|
|
|
/* Set the link info for the property list */
|
|
|
|
|
if(H5P_set(new_plist, H5G_CRT_LINK_INFO_NAME, &linfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set link info")
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Set the return value */
|
|
|
|
|
ret_value = new_gcpl_id;
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
if(ret_value < 0) {
|
|
|
|
|
if(new_gcpl_id > 0)
|
|
|
|
|
(void)H5I_dec_ref(new_gcpl_id);
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gget_create_plist() */
|
1998-07-21 05:01:32 +08:00
|
|
|
|
|
2006-11-28 02:00:08 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gget_info
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Retrieve information about a group.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Non-negative
|
|
|
|
|
* Failure: Negative
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* November 27 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
[svn-r14223] Description:
Change existing H5Gget_info -> H5Gget_info_by_name and add new version
of H5Gget_info, with simpler parameters, to better match new API routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 05:57:50 +08:00
|
|
|
|
H5Gget_info(hid_t grp_id, H5G_info_t *grp_info)
|
|
|
|
|
{
|
|
|
|
|
H5I_type_t id_type; /* Type of ID */
|
|
|
|
|
H5G_loc_t loc; /* Location of group */
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gget_info, FAIL)
|
|
|
|
|
H5TRACE2("e", "i*x", grp_id, grp_info);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
id_type = H5I_get_type(grp_id);
|
|
|
|
|
if(!(H5I_GROUP == id_type || H5I_FILE == id_type))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument")
|
|
|
|
|
if(!grp_info)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no info struct")
|
|
|
|
|
|
|
|
|
|
/* Get group location */
|
|
|
|
|
if(H5G_loc(grp_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
|
|
|
|
|
|
|
|
|
/* Retrieve the group's information */
|
|
|
|
|
if(H5G_obj_info(loc.oloc, grp_info/*out*/, H5AC_ind_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't retrieve group info")
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gget_info() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gget_info_by_name
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Retrieve information about a group.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Non-negative
|
|
|
|
|
* Failure: Negative
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* November 27 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5Gget_info_by_name(hid_t loc_id, const char *name, H5G_info_t *grp_info,
|
|
|
|
|
hid_t lapl_id)
|
2006-11-28 02:00:08 +08:00
|
|
|
|
{
|
|
|
|
|
H5G_loc_t loc; /* Location of group */
|
|
|
|
|
H5G_loc_t grp_loc; /* Location used to open group */
|
|
|
|
|
H5G_name_t grp_path; /* Opened object group hier. path */
|
|
|
|
|
H5O_loc_t grp_oloc; /* Opened object object location */
|
|
|
|
|
hbool_t loc_found = FALSE; /* Location at 'name' found */
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
[svn-r14223] Description:
Change existing H5Gget_info -> H5Gget_info_by_name and add new version
of H5Gget_info, with simpler parameters, to better match new API routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 05:57:50 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gget_info_by_name, FAIL)
|
2007-03-09 00:57:36 +08:00
|
|
|
|
H5TRACE4("e", "i*s*xi", loc_id, name, grp_info, lapl_id);
|
2006-11-28 02:00:08 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(H5G_loc(loc_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
|
|
|
|
if(!name || !*name)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
|
|
|
|
|
if(!grp_info)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no info struct")
|
|
|
|
|
if(H5P_DEFAULT == lapl_id)
|
|
|
|
|
lapl_id = H5P_LINK_ACCESS_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(lapl_id, H5P_LINK_ACCESS))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not link access property list ID")
|
|
|
|
|
|
|
|
|
|
/* Set up opened group location to fill in */
|
|
|
|
|
grp_loc.oloc = &grp_oloc;
|
|
|
|
|
grp_loc.path = &grp_path;
|
|
|
|
|
H5G_loc_reset(&grp_loc);
|
|
|
|
|
|
|
|
|
|
/* Find the group object */
|
|
|
|
|
if(H5G_loc_find(&loc, name, &grp_loc/*out*/, lapl_id, H5AC_ind_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "group not found")
|
|
|
|
|
loc_found = TRUE;
|
|
|
|
|
|
|
|
|
|
/* Retrieve the group's information */
|
|
|
|
|
if(H5G_obj_info(grp_loc.oloc, grp_info/*out*/, H5AC_ind_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't retrieve group info")
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
if(loc_found && H5G_loc_free(&grp_loc) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
[svn-r14223] Description:
Change existing H5Gget_info -> H5Gget_info_by_name and add new version
of H5Gget_info, with simpler parameters, to better match new API routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 05:57:50 +08:00
|
|
|
|
} /* end H5Gget_info_by_name() */
|
2006-11-28 02:00:08 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gget_info_by_idx
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Retrieve information about a group, according to the order
|
|
|
|
|
* of an index.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Non-negative
|
|
|
|
|
* Failure: Negative
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* November 27 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
2006-12-12 08:42:19 +08:00
|
|
|
|
H5Gget_info_by_idx(hid_t loc_id, const char *group_name, H5_index_t idx_type,
|
2006-11-28 02:00:08 +08:00
|
|
|
|
H5_iter_order_t order, hsize_t n, H5G_info_t *grp_info, hid_t lapl_id)
|
|
|
|
|
{
|
|
|
|
|
H5G_loc_t loc; /* Location of group */
|
|
|
|
|
H5G_loc_t grp_loc; /* Location used to open group */
|
|
|
|
|
H5G_name_t grp_path; /* Opened object group hier. path */
|
|
|
|
|
H5O_loc_t grp_oloc; /* Opened object object location */
|
|
|
|
|
hbool_t loc_found = FALSE; /* Entry at 'name' found */
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gget_info_by_idx, FAIL)
|
2007-03-09 00:57:36 +08:00
|
|
|
|
H5TRACE7("e", "i*sIiIoh*xi", loc_id, group_name, idx_type, order, n, grp_info,
|
|
|
|
|
lapl_id);
|
2006-11-28 02:00:08 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(H5G_loc(loc_id, &loc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
|
|
|
|
|
if(!group_name || !*group_name)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name specified")
|
2006-12-12 08:42:19 +08:00
|
|
|
|
if(idx_type <= H5_INDEX_UNKNOWN || idx_type >= H5_INDEX_N)
|
2006-11-28 02:00:08 +08:00
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index type specified")
|
|
|
|
|
if(order <= H5_ITER_UNKNOWN || order >= H5_ITER_N)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid iteration order specified")
|
|
|
|
|
if(!grp_info)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no info struct")
|
|
|
|
|
if(H5P_DEFAULT == lapl_id)
|
|
|
|
|
lapl_id = H5P_LINK_ACCESS_DEFAULT;
|
|
|
|
|
else
|
|
|
|
|
if(TRUE != H5P_isa_class(lapl_id, H5P_LINK_ACCESS))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not link access property list ID")
|
|
|
|
|
|
|
|
|
|
/* Set up opened group location to fill in */
|
|
|
|
|
grp_loc.oloc = &grp_oloc;
|
|
|
|
|
grp_loc.path = &grp_path;
|
|
|
|
|
H5G_loc_reset(&grp_loc);
|
|
|
|
|
|
|
|
|
|
/* Find the object's location, according to the order in the index */
|
|
|
|
|
if(H5G_loc_find_by_idx(&loc, group_name, idx_type, order, n, &grp_loc/*out*/, lapl_id, H5AC_ind_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "group not found")
|
|
|
|
|
loc_found = TRUE;
|
|
|
|
|
|
|
|
|
|
/* Retrieve the group's information */
|
|
|
|
|
if(H5G_obj_info(grp_loc.oloc, grp_info/*out*/, H5AC_ind_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't retrieve group info")
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
/* Release the object location */
|
|
|
|
|
if(loc_found && H5G_loc_free(&grp_loc) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gget_info_by_idx() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gclose
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Closes the specified group. The group ID will no longer be
|
|
|
|
|
* valid for accessing the group.
|
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Wednesday, December 31, 1997
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5Gclose(hid_t group_id)
|
|
|
|
|
{
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gclose, FAIL)
|
2006-12-19 03:16:17 +08:00
|
|
|
|
H5TRACE1("e", "i", group_id);
|
2006-11-28 02:00:08 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(NULL == H5I_object_verify(group_id,H5I_GROUP))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a group")
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Decrement the counter on the group atom. It will be freed if the count
|
|
|
|
|
* reaches zero.
|
|
|
|
|
*/
|
|
|
|
|
if(H5I_dec_ref(group_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close group")
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gclose() */
|
|
|
|
|
|
1997-10-21 07:14:35 +08:00
|
|
|
|
/*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
* N O A P I F U N C T I O N S B E Y O N D T H I S P O I N T
|
|
|
|
|
*-------------------------------------------------------------------------
|
2005-08-14 04:53:35 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*/
|
2006-11-07 05:35:44 +08:00
|
|
|
|
|
2006-11-12 19:56:10 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_init
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Initialize the interface from some other package.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: non-negative
|
|
|
|
|
* Failure: negative
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Saturday, November 11, 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_init(void)
|
|
|
|
|
{
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_NOAPI(H5G_init, FAIL)
|
|
|
|
|
/* FUNC_ENTER() does all the work */
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_init() */
|
|
|
|
|
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_init_interface
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Initializes the H5G interface.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-10-27 05:18:54 +08:00
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Monday, January 5, 1998
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Notes: The group creation properties are registered in the property
|
|
|
|
|
* list interface initialization routine (H5P_init_interface)
|
|
|
|
|
* so that the file creation property class can inherit from it
|
|
|
|
|
* correctly. (Which allows the file creation property list to
|
|
|
|
|
* control the group creation properties of the root group of
|
|
|
|
|
* a file) QAK - 24/10/2005
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
H5G_init_interface(void)
|
1998-01-06 11:07:15 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2006-11-02 12:54:19 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT(H5G_init_interface)
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Initialize the atom group for the group IDs */
|
2006-11-02 12:54:19 +08:00
|
|
|
|
if(H5I_register_type(H5I_GROUP, (size_t)H5I_GROUPID_HASHSIZE, H5G_RESERVED_ATOMS, (H5I_free_t)H5G_close) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to initialize interface")
|
2006-04-02 04:14:11 +08:00
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
done:
|
2006-11-02 12:54:19 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_init_interface() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_term_interface
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Terminates the H5G interface
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1999-03-30 19:38:34 +08:00
|
|
|
|
* Return: Success: Positive if anything is done that might
|
|
|
|
|
* affect other interfaces; zero otherwise.
|
|
|
|
|
*
|
|
|
|
|
* Failure: Negative.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Monday, January 5, 1998
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2001-08-15 06:09:56 +08:00
|
|
|
|
int
|
1999-03-30 19:38:34 +08:00
|
|
|
|
H5G_term_interface(void)
|
1998-01-06 11:07:15 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
int n = 0;
|
2002-05-29 02:17:12 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_term_interface)
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
if(H5_interface_initialize_g) {
|
|
|
|
|
if((n = H5I_nmembers(H5I_GROUP)))
|
2004-06-19 00:56:04 +08:00
|
|
|
|
H5I_clear_type(H5I_GROUP, FALSE);
|
2007-04-12 00:22:16 +08:00
|
|
|
|
else {
|
1999-03-30 19:38:34 +08:00
|
|
|
|
/* Destroy the group object id group */
|
2004-06-19 00:56:04 +08:00
|
|
|
|
H5I_dec_type_ref(H5I_GROUP);
|
1998-11-21 11:36:51 +08:00
|
|
|
|
|
2002-03-29 03:27:38 +08:00
|
|
|
|
/* Free the global component buffer */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_traverse_term_interface();
|
2002-03-29 03:27:38 +08:00
|
|
|
|
|
1999-03-30 19:38:34 +08:00
|
|
|
|
/* Mark closed */
|
2004-06-23 23:36:35 +08:00
|
|
|
|
H5_interface_initialize_g = 0;
|
1999-03-30 19:38:34 +08:00
|
|
|
|
n = 1; /*H5I*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end else */
|
|
|
|
|
} /* end if */
|
[svn-r876] Changes since 19981102
----------------------
./bin/snapshot
Made same fix as for the release script yesterday.
./src/H5D.c
./src/H5Dprivate.h
./src/H5G.c
./src/H5Gprivate.h
./src/H5Gpublic.h
./src/H5O.c
./src/H5Oprivate.h
./src/H5RA.c
./src/H5RAprivate.h
./src/H5T.c
./src/H5Tprivate.h
Improved object type checking. Instead of determining the
object type by trying to open each of the possible types, we
keep a table of associations between object type number (like
H5G_GROUP, H5G_DATASET, H5D_TYPE, and H5D_RAGGED) and an `isa'
function that returns true if the object header has the right
messages to make the object a particular type. This mechanism
also allows specialization of object types by permitting an
object to satisfy more than one `isa' function.
Added `isa' functions for groups, datasets, ragged arrays, and
committed data types.
./src/H5config.h.in
Added HAVE_STAT_ST_BLOCKS. I thought this had already been
added, but apparently not.
./tools/h5ls.c
Removed system include files since they're already included by
H5private.h and since I wasn't including them portably anyway.
By default, 1-byte integer types are printed as integer values
instead of ASCII characters. However, the `-s' or `--string'
command-line switch causes the data to be interpretted as
ASCII. String data types are always printed as character
data.
Ragged arrays are now identified as ragged arrays and h5ls
doesn't descend into the group automatically. This uses the
new object type specialization stuff.
./tools/h5tools.c
./tools/h5tools.h
Added the ability to print 1-byte integer types as either
ASCII or numeric data instead of always ASCII. The default is
to print as numeric data.
1998-11-06 04:28:34 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(n)
|
|
|
|
|
} /* end H5G_term_interface() */
|
[svn-r876] Changes since 19981102
----------------------
./bin/snapshot
Made same fix as for the release script yesterday.
./src/H5D.c
./src/H5Dprivate.h
./src/H5G.c
./src/H5Gprivate.h
./src/H5Gpublic.h
./src/H5O.c
./src/H5Oprivate.h
./src/H5RA.c
./src/H5RAprivate.h
./src/H5T.c
./src/H5Tprivate.h
Improved object type checking. Instead of determining the
object type by trying to open each of the possible types, we
keep a table of associations between object type number (like
H5G_GROUP, H5G_DATASET, H5D_TYPE, and H5D_RAGGED) and an `isa'
function that returns true if the object header has the right
messages to make the object a particular type. This mechanism
also allows specialization of object types by permitting an
object to satisfy more than one `isa' function.
Added `isa' functions for groups, datasets, ragged arrays, and
committed data types.
./src/H5config.h.in
Added HAVE_STAT_ST_BLOCKS. I thought this had already been
added, but apparently not.
./tools/h5ls.c
Removed system include files since they're already included by
H5private.h and since I wasn't including them portably anyway.
By default, 1-byte integer types are printed as integer values
instead of ASCII characters. However, the `-s' or `--string'
command-line switch causes the data to be interpretted as
ASCII. String data types are always printed as character
data.
Ragged arrays are now identified as ragged arrays and h5ls
doesn't descend into the group automatically. This uses the
new object type specialization stuff.
./tools/h5tools.c
./tools/h5tools.h
Added the ability to print 1-byte integer types as either
ASCII or numeric data instead of always ASCII. The default is
to print as numeric data.
1998-11-06 04:28:34 +08:00
|
|
|
|
|
1997-08-13 06:44:46 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Function: H5G_mkroot
|
1997-09-02 23:38:26 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Purpose: Creates a root group in an empty file and opens it. If a
|
|
|
|
|
* root group is already open then this function immediately
|
|
|
|
|
* returns. If ENT is non-null then it's the symbol table
|
|
|
|
|
* entry for an existing group which will be opened as the root
|
|
|
|
|
* group. Otherwise a new root group is created and then
|
|
|
|
|
* opened.
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* matzke@llnl.gov
|
|
|
|
|
* Aug 11 1997
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t
|
|
|
|
|
H5G_mkroot(H5F_t *f, hid_t dxpl_id, H5G_loc_t *loc)
|
1997-08-13 06:44:46 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5O_loc_t new_root_oloc; /* New root object location */
|
|
|
|
|
H5G_name_t new_root_path; /* New root path */
|
|
|
|
|
H5G_loc_t new_root_loc; /* New root location information */
|
|
|
|
|
H5G_loc_t root_loc; /* Root location information */
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_mkroot, FAIL)
|
2002-05-29 02:17:12 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* check args */
|
|
|
|
|
HDassert(f);
|
2007-02-22 10:00:40 +08:00
|
|
|
|
|
|
|
|
|
/* Check if the root group is already initialized */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(f->shared->root_grp)
|
|
|
|
|
HGOTO_DONE(SUCCEED)
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Create information needed for group nodes */
|
|
|
|
|
if(H5G_node_init(f) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group node info")
|
2002-09-25 22:50:49 +08:00
|
|
|
|
|
1998-03-25 07:18:34 +08:00
|
|
|
|
/*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* If there is no root object then create one. The root group always starts
|
2007-02-22 10:00:40 +08:00
|
|
|
|
* with a hard link count of one since it's pointed to by the superblock.
|
1998-03-25 07:18:34 +08:00
|
|
|
|
*/
|
2007-02-22 10:00:40 +08:00
|
|
|
|
if(loc == NULL) {
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5P_genplist_t *fc_plist; /* File creation property list */
|
|
|
|
|
H5O_ginfo_t ginfo; /* Group info parameters */
|
2006-10-30 22:33:14 +08:00
|
|
|
|
H5O_linfo_t linfo; /* Link info parameters */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Get the file creation property list */
|
|
|
|
|
/* (Which is a sub-class of the group creation property class) */
|
|
|
|
|
if(NULL == (fc_plist = H5I_object(f->shared->fcpl_id)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list")
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Get the group info property */
|
|
|
|
|
if(H5P_get(fc_plist, H5G_CRT_GROUP_INFO_NAME, &ginfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get group info")
|
1998-04-15 00:44:46 +08:00
|
|
|
|
|
2006-10-30 22:33:14 +08:00
|
|
|
|
/* Get the link info property */
|
|
|
|
|
if(H5P_get(fc_plist, H5G_CRT_LINK_INFO_NAME, &linfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get link info")
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Set up group location for root group */
|
|
|
|
|
new_root_loc.oloc = &new_root_oloc;
|
|
|
|
|
new_root_loc.path = &new_root_path;
|
|
|
|
|
H5G_loc_reset(&new_root_loc);
|
|
|
|
|
loc = &new_root_loc;
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2007-02-22 10:00:40 +08:00
|
|
|
|
/* Create root group */
|
2006-11-29 12:13:02 +08:00
|
|
|
|
if(H5G_obj_create(f, dxpl_id, &ginfo, &linfo, f->shared->fcpl_id, loc->oloc/*out*/) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group entry")
|
|
|
|
|
if(1 != H5O_link(loc->oloc, 1, dxpl_id))
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_LINKCOUNT, FAIL, "internal error (wrong link count)")
|
2007-02-22 10:00:40 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
else {
|
1998-03-25 07:18:34 +08:00
|
|
|
|
/*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Open the root object as a group.
|
1998-03-25 07:18:34 +08:00
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5O_open(loc->oloc) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open root group")
|
|
|
|
|
} /* end else */
|
1998-01-28 13:47:19 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Create the path names for the root group's entry */
|
|
|
|
|
H5G_name_init(loc->path, "/");
|
1998-01-28 13:47:19 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/*
|
|
|
|
|
* Create the group pointer. Also decrement the open object count so we
|
|
|
|
|
* don't count the root group as an open object. The root group will
|
|
|
|
|
* never be closed.
|
|
|
|
|
*/
|
|
|
|
|
if(NULL == (f->shared->root_grp = H5FL_CALLOC(H5G_t)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
|
|
|
|
|
if(NULL == (f->shared->root_grp->shared = H5FL_CALLOC(H5G_shared_t))) {
|
|
|
|
|
H5FL_FREE(H5G_t, f->shared->root_grp);
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
|
|
|
|
|
} /* end if */
|
2002-08-31 05:59:22 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Shallow copy (take ownership) of the group object info */
|
|
|
|
|
root_loc.oloc = &(f->shared->root_grp->oloc);
|
|
|
|
|
root_loc.path = &(f->shared->root_grp->path);
|
2005-12-26 13:28:18 +08:00
|
|
|
|
if(H5G_loc_copy(&root_loc, loc, H5_COPY_SHALLOW) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTCOPY, FAIL, "can't copy group object location")
|
2005-09-12 14:02:55 +08:00
|
|
|
|
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
f->shared->root_grp->shared->fo_count = 1;
|
2007-02-07 02:21:39 +08:00
|
|
|
|
/* The only other open object should be the superblock extension, if it
|
|
|
|
|
* exists. Don't count either the superblock extension or the root group
|
|
|
|
|
* in the number of open objects in the file.
|
|
|
|
|
*/
|
|
|
|
|
HDassert((1 == f->nopen_objs) ||
|
|
|
|
|
(2 == f->nopen_objs && HADDR_UNDEF != f->shared->extension_addr));
|
|
|
|
|
f->nopen_objs--;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_mkroot() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1997-08-13 06:44:46 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_create
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Creates a new empty group with the specified name. The name
|
1998-03-25 07:18:34 +08:00
|
|
|
|
* is either an absolute name or is relative to LOC.
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Return: Success: A handle for the group. The group is opened
|
|
|
|
|
* and should eventually be close by calling
|
|
|
|
|
* H5G_close().
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Failure: NULL
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* matzke@llnl.gov
|
|
|
|
|
* Aug 11 1997
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2007-04-12 00:22:16 +08:00
|
|
|
|
H5G_t *
|
|
|
|
|
H5G_create(H5F_t *file, hid_t gcpl_id, hid_t dxpl_id)
|
1997-08-13 06:44:46 +08:00
|
|
|
|
{
|
2003-06-19 04:41:28 +08:00
|
|
|
|
H5G_t *grp = NULL; /*new group */
|
2005-06-21 02:11:57 +08:00
|
|
|
|
H5P_genplist_t *gc_plist; /* Property list created */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5O_ginfo_t ginfo; /* Group info */
|
2006-10-30 22:33:14 +08:00
|
|
|
|
H5O_linfo_t linfo; /* Link info */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
unsigned oloc_init = 0; /* Flag to indicate that the group object location was created successfully */
|
2003-06-19 04:41:28 +08:00
|
|
|
|
H5G_t *ret_value; /* Return value */
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT(H5G_create)
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* check args */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
HDassert(file);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(gcpl_id != H5P_DEFAULT);
|
2007-04-12 00:22:16 +08:00
|
|
|
|
HDassert(dxpl_id != H5P_DEFAULT);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* create an open group */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(NULL == (grp = H5FL_CALLOC(H5G_t)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
|
|
|
|
|
if(NULL == (grp->shared = H5FL_CALLOC(H5G_shared_t)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
2005-06-21 02:11:57 +08:00
|
|
|
|
/* Get the property list */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(NULL == (gc_plist = H5I_object(gcpl_id)))
|
2005-06-21 02:11:57 +08:00
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a property list")
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Get the group info property */
|
|
|
|
|
if(H5P_get(gc_plist, H5G_CRT_GROUP_INFO_NAME, &ginfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get group info")
|
|
|
|
|
|
2006-10-30 22:33:14 +08:00
|
|
|
|
/* Get the link info property */
|
|
|
|
|
if(H5P_get(gc_plist, H5G_CRT_LINK_INFO_NAME, &linfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get group info")
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Create the group object header */
|
2006-11-29 12:13:02 +08:00
|
|
|
|
if(H5G_obj_create(file, dxpl_id, &ginfo, &linfo, gcpl_id, &(grp->oloc)/*out*/) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "unable to create group object header")
|
|
|
|
|
oloc_init = 1; /* Indicate that the object location information is valid */
|
|
|
|
|
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
/* Add group to list of open objects in file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_incr(grp->oloc.file, grp->oloc.addr) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINC, NULL, "can't incr object ref. count")
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(H5FO_insert(grp->oloc.file, grp->oloc.addr, grp->shared, TRUE) < 0)
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, NULL, "can't insert group into list of open objects")
|
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Set the count of times the object is opened */
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
grp->shared->fo_count = 1;
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
/* Set return value */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
ret_value = grp;
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(ret_value == NULL) {
|
2003-06-19 04:41:28 +08:00
|
|
|
|
/* Check if we need to release the file-oriented symbol table info */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(oloc_init) {
|
|
|
|
|
if(H5O_close(&(grp->oloc)) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release object header")
|
|
|
|
|
if(H5O_delete(file, dxpl_id, grp->oloc.addr) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTDELETE, NULL, "unable to delete object header")
|
2003-06-19 04:41:28 +08:00
|
|
|
|
} /* end if */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(grp != NULL) {
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
if(grp->shared != NULL)
|
|
|
|
|
H5FL_FREE(H5G_shared_t, grp->shared);
|
2002-08-09 00:52:55 +08:00
|
|
|
|
H5FL_FREE(H5G_t,grp);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end if */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_create() */
|
[svn-r876] Changes since 19981102
----------------------
./bin/snapshot
Made same fix as for the release script yesterday.
./src/H5D.c
./src/H5Dprivate.h
./src/H5G.c
./src/H5Gprivate.h
./src/H5Gpublic.h
./src/H5O.c
./src/H5Oprivate.h
./src/H5RA.c
./src/H5RAprivate.h
./src/H5T.c
./src/H5Tprivate.h
Improved object type checking. Instead of determining the
object type by trying to open each of the possible types, we
keep a table of associations between object type number (like
H5G_GROUP, H5G_DATASET, H5D_TYPE, and H5D_RAGGED) and an `isa'
function that returns true if the object header has the right
messages to make the object a particular type. This mechanism
also allows specialization of object types by permitting an
object to satisfy more than one `isa' function.
Added `isa' functions for groups, datasets, ragged arrays, and
committed data types.
./src/H5config.h.in
Added HAVE_STAT_ST_BLOCKS. I thought this had already been
added, but apparently not.
./tools/h5ls.c
Removed system include files since they're already included by
H5private.h and since I wasn't including them portably anyway.
By default, 1-byte integer types are printed as integer values
instead of ASCII characters. However, the `-s' or `--string'
command-line switch causes the data to be interpretted as
ASCII. String data types are always printed as character
data.
Ragged arrays are now identified as ragged arrays and h5ls
doesn't descend into the group automatically. This uses the
new object type specialization stuff.
./tools/h5tools.c
./tools/h5tools.h
Added the ability to print 1-byte integer types as either
ASCII or numeric data instead of always ASCII. The default is
to print as numeric data.
1998-11-06 04:28:34 +08:00
|
|
|
|
|
2007-08-28 23:02:54 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_open_name
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Opens an existing group by name.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Ptr to a new group.
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Monday, August 27, 2007
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
H5G_t *
|
|
|
|
|
H5G_open_name(const H5G_loc_t *loc, const char *name, hid_t gapl_id,
|
|
|
|
|
hid_t dxpl_id)
|
|
|
|
|
{
|
|
|
|
|
H5G_t *grp = NULL; /* Group to open */
|
|
|
|
|
H5G_loc_t grp_loc; /* Location used to open group */
|
|
|
|
|
H5G_name_t grp_path; /* Opened object group hier. path */
|
|
|
|
|
H5O_loc_t grp_oloc; /* Opened object object location */
|
|
|
|
|
H5O_type_t obj_type; /* Type of object at location */
|
|
|
|
|
hbool_t loc_found = FALSE; /* Location at 'name' found */
|
|
|
|
|
H5G_t *ret_value; /* Return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_NOAPI(H5G_open_name, NULL)
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
HDassert(loc);
|
|
|
|
|
HDassert(name);
|
|
|
|
|
|
|
|
|
|
/* Set up opened group location to fill in */
|
|
|
|
|
grp_loc.oloc = &grp_oloc;
|
|
|
|
|
grp_loc.path = &grp_path;
|
|
|
|
|
H5G_loc_reset(&grp_loc);
|
|
|
|
|
|
|
|
|
|
/* Find the group object using the gapl passed in */
|
|
|
|
|
if(H5G_loc_find(loc, name, &grp_loc/*out*/, gapl_id, dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "group not found")
|
|
|
|
|
loc_found = TRUE;
|
|
|
|
|
|
|
|
|
|
/* Check that the object found is the correct type */
|
|
|
|
|
if(H5O_obj_type(&grp_oloc, &obj_type, dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, NULL, "can't get object type")
|
|
|
|
|
if(obj_type != H5O_TYPE_GROUP)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_BADTYPE, NULL, "not a group")
|
|
|
|
|
|
|
|
|
|
/* Open the group */
|
|
|
|
|
if((grp = H5G_open(&grp_loc, dxpl_id)) == NULL)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group")
|
|
|
|
|
|
|
|
|
|
/* Set return value */
|
|
|
|
|
ret_value = grp;
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
if(!ret_value) {
|
|
|
|
|
if(loc_found && H5G_loc_free(&grp_loc) < 0)
|
2007-08-29 21:22:58 +08:00
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, NULL, "can't free location")
|
2007-08-28 23:02:54 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_open_name() */
|
|
|
|
|
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_open
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Opens an existing group. The group should eventually be
|
|
|
|
|
* closed by calling H5G_close().
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Return: Success: Ptr to a new group.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Failure: NULL
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Monday, January 5, 1998
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
1998-02-27 02:05:27 +08:00
|
|
|
|
H5G_t *
|
2007-02-21 03:58:09 +08:00
|
|
|
|
H5G_open(const H5G_loc_t *loc, hid_t dxpl_id)
|
1998-01-06 11:07:15 +08:00
|
|
|
|
{
|
2007-08-28 23:02:54 +08:00
|
|
|
|
H5G_t *grp = NULL; /* Group opened */
|
|
|
|
|
H5G_shared_t *shared_fo; /* Shared group object */
|
|
|
|
|
H5G_t *ret_value; /* Return value */
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_open, NULL)
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(loc);
|
|
|
|
|
|
|
|
|
|
/* Allocate the group structure */
|
|
|
|
|
if(NULL == (grp = H5FL_CALLOC(H5G_t)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate space for group")
|
|
|
|
|
|
|
|
|
|
/* Shallow copy (take ownership) of the group location object */
|
2005-12-26 13:28:18 +08:00
|
|
|
|
if(H5O_loc_copy(&(grp->oloc), loc->oloc, H5_COPY_SHALLOW) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTCOPY, NULL, "can't copy object location")
|
2005-12-26 13:28:18 +08:00
|
|
|
|
if(H5G_name_copy(&(grp->path), loc->path, H5_COPY_SHALLOW) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTCOPY, NULL, "can't copy path")
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
/* Check if group was already open */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if((shared_fo = H5FO_opened(grp->oloc.file, grp->oloc.addr)) == NULL) {
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
/* Clear any errors from H5FO_opened() */
|
|
|
|
|
H5E_clear_stack(NULL);
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
/* Open the group object */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5G_open_oid(grp, dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "not found")
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
/* Add group to list of open objects in file */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(H5FO_insert(grp->oloc.file, grp->oloc.addr, grp->shared, FALSE) < 0) {
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
H5FL_FREE(H5G_shared_t, grp->shared);
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, NULL, "can't insert group into list of open objects")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end if */
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
2005-10-03 13:50:05 +08:00
|
|
|
|
/* Increment object count for the object in the top file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_incr(grp->oloc.file, grp->oloc.addr) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINC, NULL, "can't increment object count")
|
|
|
|
|
|
2005-07-21 22:48:26 +08:00
|
|
|
|
/* Set open object count */
|
|
|
|
|
grp->shared->fo_count = 1;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end if */
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
else {
|
2005-07-21 22:48:26 +08:00
|
|
|
|
/* Point to shared group info */
|
|
|
|
|
grp->shared = shared_fo;
|
|
|
|
|
|
|
|
|
|
/* Increment shared reference count */
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
shared_fo->fo_count++;
|
2005-10-03 13:50:05 +08:00
|
|
|
|
|
|
|
|
|
/* Check if the object has been opened through the top file yet */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_count(grp->oloc.file, grp->oloc.addr) == 0) {
|
2005-10-03 13:50:05 +08:00
|
|
|
|
/* Open the object through this top file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5O_open(&(grp->oloc)) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open object header")
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
/* Increment object count for the object in the top file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_incr(grp->oloc.file, grp->oloc.addr) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINC, NULL, "can't increment object count")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end else */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
|
|
|
|
/* Set return value */
|
1999-03-18 08:07:50 +08:00
|
|
|
|
ret_value = grp;
|
|
|
|
|
|
|
|
|
|
done:
|
2007-08-28 23:02:54 +08:00
|
|
|
|
if (!ret_value && grp) {
|
2006-08-19 04:48:54 +08:00
|
|
|
|
H5O_loc_free(&(grp->oloc));
|
|
|
|
|
H5G_name_free(&(grp->path));
|
2000-08-17 04:13:02 +08:00
|
|
|
|
H5FL_FREE(H5G_t,grp);
|
2007-08-28 23:02:54 +08:00
|
|
|
|
} /* end if */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_open() */
|
1999-03-18 08:07:50 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_open_oid
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Opens an existing group. The group should eventually be
|
|
|
|
|
* closed by calling H5G_close().
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Ptr to a new group.
|
|
|
|
|
*
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Wednesday, March 17, 1999
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
static herr_t
|
|
|
|
|
H5G_open_oid(H5G_t *grp, hid_t dxpl_id)
|
1999-03-18 08:07:50 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
hbool_t obj_opened = FALSE;
|
|
|
|
|
herr_t ret_value = SUCCEED;
|
1999-03-18 08:07:50 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT(H5G_open_oid)
|
1999-03-18 08:07:50 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(grp);
|
1999-03-18 08:07:50 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Allocate the shared information for the group */
|
|
|
|
|
if(NULL == (grp->shared = H5FL_CALLOC(H5G_shared_t)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
|
1999-03-18 08:07:50 +08:00
|
|
|
|
|
|
|
|
|
/* Grab the object header */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5O_open(&(grp->oloc)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group")
|
|
|
|
|
obj_opened = TRUE;
|
2005-09-12 22:29:54 +08:00
|
|
|
|
|
|
|
|
|
/* Check if this object has the right message(s) to be treated as a group */
|
2007-02-06 06:26:44 +08:00
|
|
|
|
if((H5O_msg_exists(&(grp->oloc), H5O_STAB_ID, dxpl_id) <= 0)
|
|
|
|
|
&& (H5O_msg_exists(&(grp->oloc), H5O_LINFO_ID, dxpl_id) <= 0))
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "not a group")
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(ret_value < 0) {
|
|
|
|
|
if(obj_opened)
|
|
|
|
|
H5O_close(&(grp->oloc));
|
|
|
|
|
if(grp->shared)
|
|
|
|
|
H5FL_FREE(H5G_shared_t, grp->shared);
|
2005-09-12 22:29:54 +08:00
|
|
|
|
} /* end if */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_open_oid() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_close
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Closes the specified group.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-10-27 05:18:54 +08:00
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Monday, January 5, 1998
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
H5G_close(H5G_t *grp)
|
1998-01-06 11:07:15 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_close, FAIL)
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Check args */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->fo_count > 0);
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
--grp->shared->fo_count;
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(0 == grp->shared->fo_count) {
|
|
|
|
|
HDassert(grp != H5G_rootof(H5G_fileof(grp)));
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
2005-10-03 13:50:05 +08:00
|
|
|
|
/* Remove the group from the list of opened objects in the file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_decr(grp->oloc.file, grp->oloc.addr) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't decrement count for object")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_delete(grp->oloc.file, H5AC_dxpl_id, grp->oloc.addr) < 0)
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't remove group from list of open objects")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5O_close(&(grp->oloc)) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5FL_FREE(H5G_shared_t, grp->shared);
|
1998-05-02 05:16:06 +08:00
|
|
|
|
} else {
|
2005-10-03 13:50:05 +08:00
|
|
|
|
/* Decrement the ref. count for this object in the top file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_decr(grp->oloc.file, grp->oloc.addr) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't decrement count for object")
|
|
|
|
|
|
|
|
|
|
/* Check reference count for this object in the top file */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5FO_top_count(grp->oloc.file, grp->oloc.addr) == 0)
|
|
|
|
|
if(H5O_close(&(grp->oloc)) < 0)
|
2005-10-03 13:50:05 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close")
|
|
|
|
|
|
2005-07-21 22:48:26 +08:00
|
|
|
|
/* If this group is a mount point and the mount point is the last open
|
|
|
|
|
* reference to the group, then attempt to close down the file hierarchy
|
|
|
|
|
*/
|
|
|
|
|
if(grp->shared->mounted && grp->shared->fo_count == 1) {
|
|
|
|
|
/* Attempt to close down the file hierarchy */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5F_try_close(grp->oloc.file) < 0)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "problem attempting file close")
|
|
|
|
|
} /* end if */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end else */
|
2005-07-06 05:58:50 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(H5G_name_free(&(grp->path)) < 0) {
|
|
|
|
|
H5FL_FREE(H5G_t,grp);
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't free group entry name")
|
|
|
|
|
} /* end if */
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5FL_FREE(H5G_t,grp);
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
} /* end H5G_close() */
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_free
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Free memory used by an H5G_t struct (and its H5G_shared_t).
|
|
|
|
|
* Does not close the group or decrement the reference count.
|
|
|
|
|
* Used to free memory used by the root group.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Non-negative
|
|
|
|
|
* Failure: Negative
|
|
|
|
|
*
|
|
|
|
|
* Programmer: James Laird
|
|
|
|
|
* Tuesday, September 7, 2004
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_free(H5G_t *grp)
|
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
2004-12-29 22:26:20 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_free, FAIL)
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(grp && grp->shared);
|
[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:
2004-09-29 03:04:19 +08:00
|
|
|
|
|
|
|
|
|
H5FL_FREE(H5G_shared_t, grp->shared);
|
|
|
|
|
H5FL_FREE(H5G_t, grp);
|
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_free() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1997-09-20 00:36:59 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-10-14 01:17:50 +08:00
|
|
|
|
* Function: H5G_rootof
|
1997-09-20 00:36:59 +08:00
|
|
|
|
*
|
1998-10-15 03:35:08 +08:00
|
|
|
|
* Purpose: Return a pointer to the root group of the file. If the file
|
|
|
|
|
* is part of a virtual file then the root group of the virtual
|
|
|
|
|
* file is returned.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-10-15 03:35:08 +08:00
|
|
|
|
* Return: Success: Ptr to the root group of the file. Do not
|
|
|
|
|
* free the pointer -- it points directly into
|
|
|
|
|
* the file struct.
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-10-15 03:35:08 +08:00
|
|
|
|
* Failure: NULL
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
1998-10-14 01:17:50 +08:00
|
|
|
|
* Tuesday, October 13, 1998
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_t *
|
1998-10-14 01:17:50 +08:00
|
|
|
|
H5G_rootof(H5F_t *f)
|
1997-10-21 07:14:35 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_rootof)
|
2002-08-10 04:48:23 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
while(f->mtab.parent)
|
2002-08-09 00:52:55 +08:00
|
|
|
|
f = f->mtab.parent;
|
2002-08-10 04:48:23 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(f->shared->root_grp)
|
|
|
|
|
} /* end H5G_rootof() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1997-08-13 06:44:46 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Function: H5G_oloc
|
1997-09-02 23:38:26 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Purpose: Returns a pointer to the object location for a group.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Return: Success: Ptr to group entry
|
|
|
|
|
* Failure: NULL
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Tuesday, March 24, 1998
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
H5O_loc_t *
|
|
|
|
|
H5G_oloc(H5G_t *grp)
|
|
|
|
|
{
|
|
|
|
|
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_oloc)
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(grp ? &(grp->oloc) : NULL)
|
|
|
|
|
} /* end H5G_oloc() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_nameof
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Purpose: Returns a pointer to the hier. name for a group.
|
2002-09-18 23:51:29 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Return: Success: Ptr to hier. name
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Monday, September 12, 2005
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
1997-09-02 23:38:26 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_name_t *
|
|
|
|
|
H5G_nameof(H5G_t *grp)
|
1997-08-13 06:44:46 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_nameof)
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(grp ? &(grp->path) : NULL)
|
|
|
|
|
} /* end H5G_nameof() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
1997-07-31 05:17:56 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Function: H5G_fileof
|
1997-07-31 05:17:56 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Purpose: Returns the file to which the specified group belongs.
|
1997-09-02 23:38:26 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Return: Success: File pointer.
|
1997-07-31 05:17:56 +08:00
|
|
|
|
*
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Failure: NULL
|
1997-07-31 05:17:56 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
2005-11-15 10:55:39 +08:00
|
|
|
|
* Tuesday, March 24, 1998
|
1997-07-31 05:17:56 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5F_t *
|
|
|
|
|
H5G_fileof(H5G_t *grp)
|
1997-07-31 05:17:56 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_fileof)
|
1997-08-08 03:23:00 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(grp);
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(grp->oloc.file)
|
|
|
|
|
} /* end H5G_fileof() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2002-09-25 22:50:49 +08:00
|
|
|
|
|
2002-09-18 23:51:29 +08:00
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_free_grp_name
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Free the 'ID to name' buffers.
|
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
|
|
|
|
|
*
|
|
|
|
|
* Date: August 22, 2002
|
|
|
|
|
*
|
2002-09-25 22:50:49 +08:00
|
|
|
|
* Comments: Used now only on the root group close, in H5F_close()
|
2002-09-18 23:51:29 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_free_grp_name(H5G_t *grp)
|
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_free_grp_name, FAIL)
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2002-09-25 22:50:49 +08:00
|
|
|
|
/* Check args */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->fo_count > 0);
|
2002-09-25 22:50:49 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
/* Free the path */
|
|
|
|
|
H5G_name_free(&(grp->path));
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2002-08-29 02:34:12 +08:00
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_free_grp_name() */
|
2002-08-29 02:34:12 +08:00
|
|
|
|
|
2005-07-06 05:58:50 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_get_shared_count
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Queries the group object's "shared count"
|
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Tuesday, July 5, 2005
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_get_shared_count(H5G_t *grp)
|
|
|
|
|
{
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_get_shared_count)
|
2005-07-06 05:58:50 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
2005-07-21 22:48:26 +08:00
|
|
|
|
HDassert(grp && grp->shared);
|
2005-07-06 05:58:50 +08:00
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(grp->shared->fo_count)
|
2005-07-06 05:58:50 +08:00
|
|
|
|
} /* end H5G_get_shared_count() */
|
|
|
|
|
|
2005-07-21 22:48:26 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_mount
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Sets the 'mounted' flag for a group
|
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Tuesday, July 19, 2005
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_mount(H5G_t *grp)
|
|
|
|
|
{
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_mount)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->mounted == FALSE);
|
|
|
|
|
|
|
|
|
|
/* Set the 'mounted' flag */
|
|
|
|
|
grp->shared->mounted = TRUE;
|
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(SUCCEED)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
} /* end H5G_mount() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_unmount
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Resets the 'mounted' flag for a group
|
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Tuesday, July 19, 2005
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5G_unmount(H5G_t *grp)
|
|
|
|
|
{
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_unmount)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->mounted == TRUE);
|
|
|
|
|
|
|
|
|
|
/* Reset the 'mounted' flag */
|
|
|
|
|
grp->shared->mounted = FALSE;
|
|
|
|
|
|
2007-04-12 00:22:16 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(SUCCEED)
|
2005-07-21 22:48:26 +08:00
|
|
|
|
} /* end H5G_unmount() */
|
|
|
|
|
|