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 *
|
|
|
|
|
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
|
|
|
|
|
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
|
|
|
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
|
|
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 "H5FLprivate.h" /* Free Lists */
|
|
|
|
|
#include "H5Gpkg.h" /* Groups */
|
|
|
|
|
#include "H5HLprivate.h" /* Local Heaps */
|
|
|
|
|
#include "H5Iprivate.h" /* IDs */
|
2006-09-26 06:22:14 +08:00
|
|
|
|
#include "H5Lprivate.h" /* Links */
|
2003-05-09 04:09:07 +08:00
|
|
|
|
#include "H5MMprivate.h" /* Memory management */
|
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 */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
static H5G_t *H5G_create(H5F_t *file, hid_t dxpl_id, hid_t gcpl_id, hid_t gapl_id);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
static herr_t H5G_open_oid(H5G_t *grp, hid_t dxpl_id);
|
2006-08-19 04:48:54 +08:00
|
|
|
|
static herr_t H5G_insertion_loc_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
|
2006-08-03 07:41:53 +08:00
|
|
|
|
const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
|
2006-08-19 04:48:54 +08:00
|
|
|
|
H5G_own_loc_t *own_loc/*out*/);
|
2002-08-29 02:34:12 +08:00
|
|
|
|
|
1997-10-21 07:14:35 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5Gcreate
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-03-25 07:18:34 +08:00
|
|
|
|
* Purpose: Creates a new group relative to LOC_ID and gives it the
|
|
|
|
|
* specified NAME. The group is opened for write access
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* and it's object ID is returned.
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* The optional SIZE_HINT specifies how much file space to
|
|
|
|
|
* reserve to store the names that will appear in this
|
|
|
|
|
* group. If a non-positive value is supplied for the SIZE_HINT
|
|
|
|
|
* then a default size is chosen.
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* See also: H5Gset(), H5Gpush(), H5Gpop()
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
|
|
|
|
* Errors:
|
|
|
|
|
*
|
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
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Wednesday, September 24, 1997
|
1997-10-21 07:14:35 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
1998-01-06 11:07:15 +08:00
|
|
|
|
hid_t
|
1998-08-28 00:48:50 +08:00
|
|
|
|
H5Gcreate(hid_t loc_id, const char *name, size_t size_hint)
|
1997-10-21 07:14:35 +08:00
|
|
|
|
{
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_loc_t loc;
|
2006-07-06 03:01:50 +08:00
|
|
|
|
H5G_loc_t grp_loc;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_t *grp = NULL;
|
2006-08-19 04:48:54 +08:00
|
|
|
|
H5G_loc_t insertion_loc; /* Loc of group in which to create object */
|
|
|
|
|
H5G_name_t insert_path; /* Path of group in which to create object */
|
|
|
|
|
H5O_loc_t insert_oloc; /* oloc of group in which to create object */
|
|
|
|
|
hbool_t insert_loc_valid = FALSE; /* Is insertion_loc valid? */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
H5F_t *file; /* File the group will be inserted into */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
hid_t tmp_gcpl = (-1); /* Temporary group creation property list */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
hid_t grp_id = (-1); /* ID of group being created */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
hid_t ret_value;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gcreate, FAIL)
|
[svn-r429] Changes since 19980616
----------------------
./html/tracing.html NEW
This entire update is to make it possible for the library to
print the name, arguments, and return value of every API call
without requiring any extra work from developers or app
programmers. This file describes how this all works.
./configure.in
Added the `--enable-tracing' switch. If you use it then the
library will include code to print API function names,
argument names and values, and function return values.
However, you must then turn on the tracing by setting the
HDF5_TRACE environment variable to a file descriptor number.
The default is `--disable-tracing' since enabling it causes a
slight increase in library size and a slowdown resulting from
an extra function call for each API function call (I couldn't
even measure the slowdown :-)
./bin/trace NEW
A perl script that synchronizes the H5TRACE() macro calls in
the *.c files with the function return type and formal
argument names and types. If you use GNU make and gcc then
this will be done automatically, otherwise just invoke this
script with the names of one or more .c files. You could do
it by hand to, but encoding argument types is a little tricky
at first.
./config/commence.in
Added the $(TRACE) macro, which defaults to the no-op.
Added -D_POSIX_SOURCE to the compiler command line.
./src/Makefile.in
Override the default for $(TRACE).
./config/depend.in
Automatically calls $(TRACE) to synchronize the H5TRACE()
macros in any source file that changed. As with makefile
dependencies, one way to force synchronization of all files is
to remove the `.depend' file.
./MANIFEST
Added new files.
./src/H5Eprivate.h
Modified HRETURN_ERROR() and HRETURN() for tracing.
./src/H5.c
./src/H5private.h
This is where the real tracing work really happens, in
H5_trace().
./src/H5A.c
./src/H5D.c
./src/H5G.c
./src/H5P.c
./src/H5S.c
./src/H5Z.c
Added H5TRACE() calls to all API functions. You don't really
need these changes if you don't want to merge your stuff
because they can be generated automatically by going to the
hdf5/src directory and saying ../bin/trace *.c
./src/H5T.c
Added H5TRACE() calls. Other stuff below.
./src/H5E.c
./src/H5Epublic.h
Added H5TRACE() calls. Created a type H5E_auto_t for the
`func' argument of H5Eset_auto() and H5Eget_auto() to make
those arguments easier to parse for tracing. It should also
make it clearer for users that don't know how to read
complicated ANSI data types.
./src/H5F.c
Added H5TRACE() calls. Changed a couple `uintn' argument
types in API functions to `unsigned int' since `uintn' part of
the API. Changed a few "can't" and "cant" error messages to
"unable to".
./src/H5Ipublic.h
Removed H5_DIRECTORY from the H5I_group_t enum. It wasn't
used anywhere.
./src/H5Tconv.c
Removed an unused label.
./src/H5Fistore.c
./src/H5Oattr.c
./src/H5Odtype.c
./src/H5T.c
./test/dsets.c
./test/dtypes.c
Fixed a warning about a variable possibly used before it's
initialized. Added __unused__ to turn off some unused
argument warnings that pop up when debugging is turned off and
optimizations are turned on.
1998-06-18 04:46:29 +08:00
|
|
|
|
H5TRACE3("i","isz",loc_id,name,size_hint);
|
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)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name given")
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2005-09-12 22:29:54 +08:00
|
|
|
|
/* Check if we need to create a non-standard GCPL */
|
|
|
|
|
if(size_hint > 0) {
|
|
|
|
|
H5P_genplist_t *gc_plist; /* Property list created */
|
|
|
|
|
H5O_ginfo_t ginfo; /* Group info property */
|
|
|
|
|
|
|
|
|
|
/* Get the default property list */
|
|
|
|
|
if(NULL == (gc_plist = H5I_object(H5P_GROUP_CREATE_DEFAULT)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list")
|
|
|
|
|
|
|
|
|
|
/* Make a copy of the default property list */
|
|
|
|
|
if((tmp_gcpl = H5P_copy_plist(gc_plist)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to copy the creation property list")
|
|
|
|
|
|
|
|
|
|
/* Get the copy of the property list */
|
|
|
|
|
if(NULL == (gc_plist = H5I_object(H5P_GROUP_CREATE_DEFAULT)))
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list")
|
|
|
|
|
|
|
|
|
|
/* Get the group info property */
|
|
|
|
|
if(H5P_get(gc_plist, H5G_CRT_GROUP_INFO_NAME, &ginfo) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get group info")
|
|
|
|
|
|
|
|
|
|
/* Set the non-default local heap size hint */
|
|
|
|
|
ginfo.lheap_size_hint = size_hint;
|
|
|
|
|
if(H5P_set(gc_plist, H5G_CRT_GROUP_INFO_NAME, &ginfo) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set group info")
|
2005-09-12 22:29:54 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
else
|
|
|
|
|
tmp_gcpl = H5P_GROUP_CREATE_DEFAULT;
|
|
|
|
|
|
2006-07-06 03:01:50 +08:00
|
|
|
|
/* What file is the group being added to? This may not be the same file
|
|
|
|
|
* that loc_id is in if mounting is being used. */
|
2006-08-19 04:48:54 +08:00
|
|
|
|
insertion_loc.path = &insert_path;
|
|
|
|
|
insertion_loc.oloc = &insert_oloc;
|
|
|
|
|
H5G_loc_reset(&insertion_loc);
|
|
|
|
|
if(H5G_insertion_loc(&loc, name, &insertion_loc, H5AC_dxpl_id) < 0)
|
2006-11-22 04:22:11 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to locate insertion point")
|
2006-08-19 04:48:54 +08:00
|
|
|
|
insert_loc_valid=TRUE;
|
|
|
|
|
file = insertion_loc.oloc->file;
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Create the group */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(NULL == (grp = H5G_create(file, H5AC_dxpl_id, tmp_gcpl, H5P_DEFAULT)))
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group")
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Get an ID for the newly created group */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if((grp_id = H5I_register(H5I_GROUP, grp)) < 0)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Get the new group's location */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(H5G_loc(grp_id, &grp_loc) <0)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to get location for new group")
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Link the new group to its parent group */
|
|
|
|
|
if(H5L_link(&loc, name, &grp_loc, H5P_DEFAULT, H5P_DEFAULT, H5AC_dxpl_id) < 0)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_LINK, H5E_CANTINIT, FAIL, "unable to create link to group")
|
2006-07-06 03:01:50 +08:00
|
|
|
|
|
2006-10-02 18:24:03 +08:00
|
|
|
|
/* Set the return value */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
ret_value = grp_id;
|
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
done:
|
2005-09-12 22:29:54 +08:00
|
|
|
|
if(tmp_gcpl > 0 && tmp_gcpl != H5P_GROUP_CREATE_DEFAULT)
|
|
|
|
|
if(H5I_dec_ref(tmp_gcpl) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release property list")
|
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
if(insert_loc_valid) {
|
|
|
|
|
if(H5G_loc_free(&insertion_loc) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_OHDR, H5E_CANTRELEASE, FAIL, "unable to free location")
|
|
|
|
|
}
|
2005-09-12 22:29:54 +08:00
|
|
|
|
if(ret_value < 0) {
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(grp_id >= 0)
|
|
|
|
|
H5I_dec_ref(grp_id);
|
|
|
|
|
else if(grp!=NULL)
|
2002-08-09 00:52:55 +08:00
|
|
|
|
H5G_close(grp);
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gcreate() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2005-06-21 02:11:57 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gcreate_expand
|
|
|
|
|
*
|
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
|
2006-07-10 23:47:58 +08:00
|
|
|
|
* H5Llink or it will be deleted when closed.
|
2006-07-06 03:01:50 +08:00
|
|
|
|
*
|
|
|
|
|
* Given the default setting, H5Gcreate_expand() followed by
|
2006-07-10 23:47:58 +08:00
|
|
|
|
* H5Llink() will have the same function as H5Gcreate().
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
2006-04-02 04:14:11 +08:00
|
|
|
|
* Usage: H5Gcreate_expand(loc_id, char *name, gcpl_id, gapl_id)
|
|
|
|
|
* hid_t loc_id; IN: File or group identifier
|
2006-06-27 22:45:06 +08:00
|
|
|
|
* 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);
|
|
|
|
|
* hid_t gid = H5Gcreate_expand(file_id, "/A/B01/grp", create_id, H5P_DEFAULT);
|
|
|
|
|
*
|
|
|
|
|
* See also: H5Gcreate(), H5Dcreate_expand(), H5Pset_create_intermediate_group()
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*
|
|
|
|
|
* Errors:
|
|
|
|
|
*
|
|
|
|
|
* 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
|
2005-06-21 02:11:57 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
2006-07-06 03:01:50 +08:00
|
|
|
|
H5Gcreate_expand(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
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gcreate_expand, FAIL)
|
2006-07-06 03:01:50 +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 */
|
2006-07-06 03:01:50 +08:00
|
|
|
|
if(NULL == (grp = H5G_create(loc.oloc->file, H5AC_dxpl_id, gcpl_id, gapl_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:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(ret_value < 0) {
|
2005-06-21 02:11:57 +08:00
|
|
|
|
if(grp!=NULL)
|
|
|
|
|
H5G_close(grp);
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
|
|
|
|
} /* end H5Gcreate_expand() */
|
|
|
|
|
|
1998-01-06 11:07:15 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5Gopen
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Opens an existing group for modification. When finished,
|
|
|
|
|
* call H5Gclose() to close it and release resources.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
* Errors:
|
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Return: Success: Object ID of the group.
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Failure: FAIL
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Wednesday, December 31, 1997
|
1998-01-06 11:07:15 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
1998-08-28 00:48:50 +08:00
|
|
|
|
H5Gopen(hid_t loc_id, const char *name)
|
1998-01-06 11:07:15 +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
|
|
|
|
H5G_t *grp = NULL;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_loc_t loc;
|
|
|
|
|
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 */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
H5O_type_t obj_type; /* Type of object at location */
|
2006-08-19 04:48:54 +08:00
|
|
|
|
hbool_t loc_found = FALSE; /* Location at 'name' found */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
hid_t ret_value; /* Return value */
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_API(H5Gopen, FAIL)
|
[svn-r429] Changes since 19980616
----------------------
./html/tracing.html NEW
This entire update is to make it possible for the library to
print the name, arguments, and return value of every API call
without requiring any extra work from developers or app
programmers. This file describes how this all works.
./configure.in
Added the `--enable-tracing' switch. If you use it then the
library will include code to print API function names,
argument names and values, and function return values.
However, you must then turn on the tracing by setting the
HDF5_TRACE environment variable to a file descriptor number.
The default is `--disable-tracing' since enabling it causes a
slight increase in library size and a slowdown resulting from
an extra function call for each API function call (I couldn't
even measure the slowdown :-)
./bin/trace NEW
A perl script that synchronizes the H5TRACE() macro calls in
the *.c files with the function return type and formal
argument names and types. If you use GNU make and gcc then
this will be done automatically, otherwise just invoke this
script with the names of one or more .c files. You could do
it by hand to, but encoding argument types is a little tricky
at first.
./config/commence.in
Added the $(TRACE) macro, which defaults to the no-op.
Added -D_POSIX_SOURCE to the compiler command line.
./src/Makefile.in
Override the default for $(TRACE).
./config/depend.in
Automatically calls $(TRACE) to synchronize the H5TRACE()
macros in any source file that changed. As with makefile
dependencies, one way to force synchronization of all files is
to remove the `.depend' file.
./MANIFEST
Added new files.
./src/H5Eprivate.h
Modified HRETURN_ERROR() and HRETURN() for tracing.
./src/H5.c
./src/H5private.h
This is where the real tracing work really happens, in
H5_trace().
./src/H5A.c
./src/H5D.c
./src/H5G.c
./src/H5P.c
./src/H5S.c
./src/H5Z.c
Added H5TRACE() calls to all API functions. You don't really
need these changes if you don't want to merge your stuff
because they can be generated automatically by going to the
hdf5/src directory and saying ../bin/trace *.c
./src/H5T.c
Added H5TRACE() calls. Other stuff below.
./src/H5E.c
./src/H5Epublic.h
Added H5TRACE() calls. Created a type H5E_auto_t for the
`func' argument of H5Eset_auto() and H5Eget_auto() to make
those arguments easier to parse for tracing. It should also
make it clearer for users that don't know how to read
complicated ANSI data types.
./src/H5F.c
Added H5TRACE() calls. Changed a couple `uintn' argument
types in API functions to `unsigned int' since `uintn' part of
the API. Changed a few "can't" and "cant" error messages to
"unable to".
./src/H5Ipublic.h
Removed H5_DIRECTORY from the H5I_group_t enum. It wasn't
used anywhere.
./src/H5Tconv.c
Removed an unused label.
./src/H5Fistore.c
./src/H5Oattr.c
./src/H5Odtype.c
./src/H5T.c
./test/dsets.c
./test/dtypes.c
Fixed a warning about a variable possibly used before it's
initialized. Added __unused__ to turn off some unused
argument warnings that pop up when debugging is turned off and
optimizations are turned on.
1998-06-18 04:46:29 +08:00
|
|
|
|
H5TRACE2("i","is",loc_id,name);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
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)
|
|
|
|
|
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
|
|
|
|
|
|
|
|
|
|
/* Set up opened group location to fill in */
|
|
|
|
|
grp_loc.oloc = &grp_oloc;
|
|
|
|
|
grp_loc.path = &grp_path;
|
|
|
|
|
H5G_loc_reset(&grp_loc);
|
[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
|
|
|
|
/* Find the group object */
|
2006-08-03 07:41:53 +08:00
|
|
|
|
if(H5G_loc_find(&loc, name, &grp_loc/*out*/, H5P_DEFAULT, H5AC_dxpl_id) < 0)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "group not found")
|
2006-08-19 04:48:54 +08:00
|
|
|
|
loc_found = TRUE;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
|
|
|
|
|
/* Check that the object found is the correct type */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
if(H5O_obj_type(&grp_oloc, &obj_type, H5AC_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't get object type")
|
|
|
|
|
if(obj_type != H5O_TYPE_GROUP)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_BADTYPE, FAIL, "not a group")
|
[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
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Open the group */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if((grp = H5G_open(&grp_loc, H5AC_dxpl_id)) == NULL)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group")
|
2004-12-29 22:26:20 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Register an atom for the group */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if((ret_value = H5I_register(H5I_GROUP, grp)) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if(ret_value < 0) {
|
|
|
|
|
if(grp != NULL)
|
2002-08-09 00:52:55 +08:00
|
|
|
|
H5G_close(grp);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
else {
|
2006-08-19 04:48:54 +08:00
|
|
|
|
if(loc_found) {
|
|
|
|
|
if(H5G_loc_free(&grp_loc) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
|
|
|
|
|
}
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} /* end else */
|
2002-08-09 00:52:55 +08:00
|
|
|
|
} /* end if */
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
2006-11-28 02:00:08 +08:00
|
|
|
|
} /* end H5Gopen() */
|
1998-03-25 07:18:34 +08:00
|
|
|
|
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5Gopen_expand
|
|
|
|
|
*
|
|
|
|
|
* 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
|
|
|
|
|
* Property List, which H5Gopen() does not.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Object ID of the group.
|
|
|
|
|
* Failure: FAIL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: James Laird
|
|
|
|
|
* Thursday, July 27, 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
hid_t
|
|
|
|
|
H5Gopen_expand(hid_t loc_id, const char *name, hid_t gapl_id)
|
|
|
|
|
{
|
|
|
|
|
H5G_t *grp = NULL;
|
|
|
|
|
H5G_loc_t loc;
|
|
|
|
|
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 */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
H5O_type_t obj_type; /* Type of object at location */
|
2006-08-19 04:48:54 +08:00
|
|
|
|
hbool_t loc_found = FALSE; /* Location at 'name' found */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
hid_t ret_value; /* Return value */
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gopen_expand, FAIL);
|
|
|
|
|
H5TRACE3("i","isi",loc_id,name,gapl_id);
|
|
|
|
|
|
|
|
|
|
/* 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")
|
|
|
|
|
|
|
|
|
|
/* 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, H5AC_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "group not found")
|
2006-08-19 04:48:54 +08:00
|
|
|
|
loc_found = TRUE;
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
|
|
|
|
/* Check that the object found is the correct type */
|
2006-11-22 04:22:11 +08:00
|
|
|
|
if(H5O_obj_type(&grp_oloc, &obj_type, H5AC_dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't get object type")
|
|
|
|
|
if(obj_type != H5O_TYPE_GROUP)
|
2006-08-03 07:41:53 +08:00
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_BADTYPE, FAIL, "not a group")
|
|
|
|
|
|
|
|
|
|
/* Open the group */
|
|
|
|
|
if((grp = H5G_open(&grp_loc, H5AC_dxpl_id)) == NULL)
|
|
|
|
|
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) {
|
|
|
|
|
if(grp != NULL)
|
|
|
|
|
H5G_close(grp);
|
|
|
|
|
else {
|
2006-08-19 04:48:54 +08:00
|
|
|
|
if(loc_found) {
|
|
|
|
|
if(H5G_loc_free(&grp_loc) < 0)
|
|
|
|
|
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
|
|
|
|
|
}
|
2006-08-03 07:41:53 +08:00
|
|
|
|
} /* end else */
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_API(ret_value)
|
2006-11-28 02:00:08 +08:00
|
|
|
|
} /* end H5Gopen_expand() */
|
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)
|
2005-11-18 23:55:22 +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")
|
|
|
|
|
|
|
|
|
|
/* Check for the group having a group info message */
|
|
|
|
|
if((ginfo_exists = H5O_exists(&(grp->oloc), H5O_GINFO_ID, 0, H5AC_dxpl_id)) < 0)
|
|
|
|
|
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 */
|
|
|
|
|
if(NULL == H5O_read(&(grp->oloc), H5O_GINFO_ID, 0, &ginfo, H5AC_dxpl_id))
|
|
|
|
|
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 */
|
|
|
|
|
if((linfo_exists = H5O_exists(&(grp->oloc), H5O_LINFO_ID, 0, H5AC_dxpl_id)) < 0)
|
|
|
|
|
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 */
|
|
|
|
|
if(NULL == H5O_read(&(grp->oloc), H5O_LINFO_ID, 0, &linfo, H5AC_dxpl_id))
|
|
|
|
|
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
|
|
|
|
|
H5Gget_info(hid_t loc_id, const char *name, 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; /* Location at 'name' found */
|
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gget_info, FAIL)
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
} /* end H5Gget_info() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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
|
|
|
|
|
H5Gget_info_by_idx(hid_t loc_id, const char *group_name, H5L_index_t idx_type,
|
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
/* 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")
|
|
|
|
|
if(idx_type <= H5L_INDEX_UNKNOWN || idx_type >= H5L_INDEX_N)
|
|
|
|
|
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 */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER_API(H5Gclose, FAIL);
|
|
|
|
|
H5TRACE1("e","i",group_id);
|
|
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
2004-06-23 23:36:35 +08:00
|
|
|
|
if (H5_interface_initialize_g) {
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if ((n = H5I_nmembers(H5I_GROUP))) {
|
2004-06-19 00:56:04 +08:00
|
|
|
|
H5I_clear_type(H5I_GROUP, FALSE);
|
1999-03-30 19:38:34 +08:00
|
|
|
|
} else {
|
|
|
|
|
/* 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
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Function: H5G_component
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Purpose: Returns the pointer to the first component of the
|
|
|
|
|
* specified name by skipping leading slashes. Returns
|
|
|
|
|
* the size in characters of the component through SIZE_P not
|
|
|
|
|
* counting leading slashes or the null terminator.
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Return: Success: Ptr into NAME.
|
1997-08-13 06:44:46 +08:00
|
|
|
|
*
|
1998-01-28 13:47:19 +08:00
|
|
|
|
* Failure: Ptr to the null terminator of NAME.
|
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
|
|
|
|
const char *
|
1998-01-17 06:23:43 +08:00
|
|
|
|
H5G_component(const char *name, size_t *size_p)
|
1997-08-13 06:44:46 +08:00
|
|
|
|
{
|
2003-12-07 04:38:31 +08:00
|
|
|
|
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_component)
|
2002-05-29 02:17:12 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(name);
|
1997-08-13 06:44:46 +08:00
|
|
|
|
|
2002-08-09 00:52:55 +08:00
|
|
|
|
while ('/' == *name)
|
|
|
|
|
name++;
|
|
|
|
|
if (size_p)
|
|
|
|
|
*size_p = HDstrcspn(name, "/");
|
2002-05-29 02:17:12 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(name)
|
|
|
|
|
} /* end H5G_component() */
|
1998-09-22 23:27:26 +08:00
|
|
|
|
|
2003-08-17 02:54:40 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_normalize
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Returns a pointer to a new string which has duplicate and
|
|
|
|
|
* trailing slashes removed from it.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: Ptr to normalized name.
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Saturday, August 16, 2003
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2006-07-06 03:01:50 +08:00
|
|
|
|
char *
|
2003-08-17 02:54:40 +08:00
|
|
|
|
H5G_normalize(const char *name)
|
|
|
|
|
{
|
|
|
|
|
char *norm; /* Pointer to the normalized string */
|
|
|
|
|
size_t s,d; /* Positions within the strings */
|
|
|
|
|
unsigned last_slash; /* Flag to indicate last character was a slash */
|
|
|
|
|
char *ret_value; /* Return value */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2003-12-07 04:38:31 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT(H5G_normalize);
|
2003-08-17 02:54:40 +08:00
|
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
|
|
/* Duplicate the name, to return */
|
|
|
|
|
if (NULL==(norm=H5MM_strdup(name)))
|
|
|
|
|
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for normalized string");
|
|
|
|
|
|
|
|
|
|
/* Walk through the characters, omitting duplicated '/'s */
|
|
|
|
|
s=d=0;
|
|
|
|
|
last_slash=0;
|
|
|
|
|
while(name[s]!='\0') {
|
|
|
|
|
if(name[s]=='/')
|
|
|
|
|
if(last_slash)
|
|
|
|
|
;
|
|
|
|
|
else {
|
|
|
|
|
norm[d++]=name[s];
|
|
|
|
|
last_slash=1;
|
|
|
|
|
} /* end else */
|
|
|
|
|
else {
|
|
|
|
|
norm[d++]=name[s];
|
|
|
|
|
last_slash=0;
|
|
|
|
|
} /* end else */
|
|
|
|
|
s++;
|
|
|
|
|
} /* end while */
|
|
|
|
|
|
|
|
|
|
/* Terminate normalized string */
|
|
|
|
|
norm[d]='\0';
|
|
|
|
|
|
|
|
|
|
/* Check for final '/' on normalized name & eliminate it */
|
|
|
|
|
if(d>1 && last_slash)
|
|
|
|
|
norm[d-1]='\0';
|
|
|
|
|
|
|
|
|
|
/* Set return value */
|
|
|
|
|
ret_value=norm;
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value);
|
|
|
|
|
} /* end H5G_normalize() */
|
|
|
|
|
|
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);
|
|
|
|
|
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
|
|
|
|
|
* with a hard link count of one since it's pointed to by the boot block.
|
1998-03-25 07:18:34 +08:00
|
|
|
|
*/
|
2005-11-15 10:55:39 +08:00
|
|
|
|
if (loc == NULL) {
|
|
|
|
|
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
|
|
|
|
|
2006-10-30 22:33:14 +08:00
|
|
|
|
if(H5G_obj_create(f, dxpl_id, &ginfo, &linfo, 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)")
|
2005-11-15 10:55:39 +08:00
|
|
|
|
} 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;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(1 == f->nopen_objs);
|
1998-10-15 03:35:08 +08:00
|
|
|
|
f->nopen_objs = 0;
|
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
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2003-02-11 01:26:09 +08:00
|
|
|
|
static H5G_t *
|
2006-07-06 03:01:50 +08:00
|
|
|
|
H5G_create(H5F_t *file, hid_t dxpl_id, hid_t gcpl_id, hid_t UNUSED gapl_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);
|
2005-06-21 02:11:57 +08:00
|
|
|
|
#ifdef LATER
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(gapl_id != H5P_DEFAULT);
|
2005-06-21 02:11:57 +08:00
|
|
|
|
#endif /* LATER */
|
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-10-30 22:33:14 +08:00
|
|
|
|
if(H5G_obj_create(file, dxpl_id, &ginfo, &linfo, &(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
|
|
|
|
|
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 *
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_open(H5G_loc_t *loc, hid_t dxpl_id)
|
1998-01-06 11:07:15 +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
|
|
|
|
H5G_t *grp = NULL;
|
2005-11-15 10:55:39 +08:00
|
|
|
|
H5G_shared_t *shared_fo = NULL;
|
|
|
|
|
H5G_t *ret_value = NULL;
|
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:
|
2002-08-09 00:52:55 +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);
|
2006-08-19 04:48:54 +08:00
|
|
|
|
}
|
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 */
|
2006-10-02 18:24:03 +08:00
|
|
|
|
if((H5O_exists(&(grp->oloc), H5O_STAB_ID, 0, dxpl_id) <= 0)
|
|
|
|
|
&& (H5O_exists(&(grp->oloc), H5O_LINFO_ID, 0, 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
|
|
|
|
|
2006-11-22 04:22:11 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: H5G_map_obj_type
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Maps the object type to the older "group" object type
|
|
|
|
|
*
|
|
|
|
|
* Return: Object type (can't fail)
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol
|
|
|
|
|
* Tuesday, November 21, 2006
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
H5G_obj_t
|
|
|
|
|
H5G_map_obj_type(H5O_type_t obj_type)
|
|
|
|
|
{
|
|
|
|
|
H5G_obj_t ret_value; /* Return value */
|
|
|
|
|
|
|
|
|
|
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_map_obj_type)
|
|
|
|
|
|
|
|
|
|
/* Map object type to older "group" object type */
|
|
|
|
|
switch(obj_type) {
|
|
|
|
|
case H5O_TYPE_GROUP:
|
|
|
|
|
ret_value = H5G_GROUP;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5O_TYPE_DATASET:
|
|
|
|
|
ret_value = H5G_DATASET;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5O_TYPE_NAMED_DATATYPE:
|
|
|
|
|
ret_value = H5G_TYPE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
ret_value = H5G_UNKNOWN;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
|
|
|
|
} /* end H5G_map_obj_type() */
|
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Function: H5G_insertion_loc_cb
|
2005-11-15 10:55:39 +08:00
|
|
|
|
*
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Purpose: Callback for finding insertion location. This routine sets the
|
|
|
|
|
* correct information in the location passed in through the udata.
|
2005-11-15 10:55:39 +08:00
|
|
|
|
*
|
|
|
|
|
* Return: Non-negative on success/Negative on failure
|
|
|
|
|
*
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Programmer: James Laird
|
|
|
|
|
* Wednesday, August 16, 2006
|
2005-11-15 10:55:39 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
2006-08-19 04:48:54 +08:00
|
|
|
|
H5G_insertion_loc_cb(H5G_loc_t *grp_loc/*in*/, const char UNUSED *name, const H5O_link_t UNUSED *lnk,
|
|
|
|
|
H5G_loc_t *obj_loc, void *_udata/*in,out*/, H5G_own_loc_t *own_loc/*out*/)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
{
|
2006-11-25 12:10:32 +08:00
|
|
|
|
H5G_trav_ins_t *udata = (H5G_trav_ins_t *)_udata; /* User data passed in */
|
2005-11-15 10:55:39 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT(H5G_insertion_loc_cb)
|
2005-11-15 10:55:39 +08:00
|
|
|
|
|
|
|
|
|
/* Check if the name in this group resolves to a valid location */
|
|
|
|
|
/* (which is not what we want) */
|
|
|
|
|
if(obj_loc != NULL)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "name already exists")
|
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
/* Take ownership of the grp_loc */
|
|
|
|
|
if(H5G_loc_copy(udata->loc, grp_loc, H5_COPY_SHALLOW) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_CANTCOPY, FAIL, "couldn't take ownership of group location")
|
|
|
|
|
*own_loc = H5G_OWN_GRP_LOC;
|
2006-08-03 07:41:53 +08:00
|
|
|
|
|
2005-11-15 10:55:39 +08:00
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
2006-08-19 04:48:54 +08:00
|
|
|
|
} /* end H5G_insertion_loc_cb() */
|
1998-10-15 03:35:08 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Function: H5G_insertion_loc
|
1998-10-15 03:35:08 +08:00
|
|
|
|
*
|
|
|
|
|
* Purpose: Given a location and name that specifies a not-yet-existing
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* object return the location of the group into which the object
|
|
|
|
|
* is about to be inserted.
|
1998-10-15 03:35:08 +08:00
|
|
|
|
*
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Return: Success: H5G_loc_t pointer
|
|
|
|
|
* (should be released with H5G_loc_free)
|
1998-10-15 03:35:08 +08:00
|
|
|
|
*
|
|
|
|
|
* Failure: NULL
|
|
|
|
|
*
|
2006-08-19 04:48:54 +08:00
|
|
|
|
* Programmer: James Laird
|
|
|
|
|
* Wednesday, August 16, 2006
|
1998-10-15 03:35:08 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2006-08-19 04:48:54 +08:00
|
|
|
|
herr_t
|
|
|
|
|
H5G_insertion_loc(H5G_loc_t *src_loc, const char *name,
|
|
|
|
|
H5G_loc_t *insertion_loc/*out*/, hid_t dxpl_id)
|
1998-10-15 03:35:08 +08:00
|
|
|
|
{
|
2006-11-25 12:10:32 +08:00
|
|
|
|
H5G_trav_ins_t udata; /* User data for traversal */
|
2006-08-19 04:48:54 +08:00
|
|
|
|
herr_t ret_value = SUCCEED; /* Return value */
|
1998-10-15 03:35:08 +08:00
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
FUNC_ENTER_NOAPI(H5G_insertion_loc, FAIL)
|
[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
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
HDassert(src_loc);
|
|
|
|
|
HDassert(insertion_loc);
|
2005-11-15 10:55:39 +08:00
|
|
|
|
HDassert(name && *name);
|
1998-10-15 03:35:08 +08:00
|
|
|
|
|
2006-08-19 04:48:54 +08:00
|
|
|
|
/*
|
|
|
|
|
* Look up the name to get the containing group's location and to make
|
|
|
|
|
* sure the name doesn't already exist.
|
1998-10-15 03:35:08 +08:00
|
|
|
|
*/
|
2006-08-19 04:48:54 +08:00
|
|
|
|
udata.loc = insertion_loc;
|
|
|
|
|
if(H5G_traverse(src_loc, name, H5G_TARGET_NORMAL, H5G_insertion_loc_cb, &udata, H5P_DEFAULT, dxpl_id) < 0)
|
|
|
|
|
HGOTO_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "name already exists")
|
2002-08-09 00:52:55 +08:00
|
|
|
|
|
|
|
|
|
done:
|
2005-11-15 10:55:39 +08:00
|
|
|
|
FUNC_LEAVE_NOAPI(ret_value)
|
2006-08-19 04:48:54 +08:00
|
|
|
|
} /* end H5G_insertion_loc() */
|
2002-08-29 02:34:12 +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)
|
|
|
|
|
{
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_get_shared_count);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
2005-07-21 22:48:26 +08:00
|
|
|
|
HDassert(grp && grp->shared);
|
2005-07-06 05:58:50 +08:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(grp->shared->fo_count);
|
|
|
|
|
} /* 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)
|
|
|
|
|
{
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_mount);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->mounted == FALSE);
|
|
|
|
|
|
|
|
|
|
/* Set the 'mounted' flag */
|
|
|
|
|
grp->shared->mounted = TRUE;
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(SUCCEED);
|
|
|
|
|
} /* 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)
|
|
|
|
|
{
|
|
|
|
|
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_unmount);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
HDassert(grp && grp->shared);
|
|
|
|
|
HDassert(grp->shared->mounted == TRUE);
|
|
|
|
|
|
|
|
|
|
/* Reset the 'mounted' flag */
|
|
|
|
|
grp->shared->mounted = FALSE;
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE_NOAPI(SUCCEED);
|
|
|
|
|
} /* end H5G_unmount() */
|
|
|
|
|
|