summaryrefslogtreecommitdiffstats
path: root/src/H5S.c
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>1998-02-25 18:48:33 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>1998-02-25 18:48:33 (GMT)
commitfaa3f5739e0b52d84d119791b6859fe610b76d37 (patch)
tree6c1849a3516a7bf19a4f33af1868bb55e536c3d3 /src/H5S.c
parent1f96b24ba70e33d1c87dd5773d3ef18d1f46a3c5 (diff)
downloadhdf5-faa3f5739e0b52d84d119791b6859fe610b76d37.zip
hdf5-faa3f5739e0b52d84d119791b6859fe610b76d37.tar.gz
hdf5-faa3f5739e0b52d84d119791b6859fe610b76d37.tar.bz2
[svn-r296] Switched prefix for dataspaces from H5P to H5S
Diffstat (limited to 'src/H5S.c')
-rw-r--r--src/H5S.c1294
1 files changed, 1294 insertions, 0 deletions
diff --git a/src/H5S.c b/src/H5S.c
new file mode 100644
index 0000000..c6f03b2
--- /dev/null
+++ b/src/H5S.c
@@ -0,0 +1,1294 @@
+/****************************************************************************
+* NCSA HDF *
+* Software Development Group *
+* National Center for Supercomputing Applications *
+* University of Illinois at Urbana-Champaign *
+* 605 E. Springfield, Champaign IL 61820 *
+* *
+* For conditions of distribution and use, see the accompanying *
+* hdf/COPYING file. *
+* *
+****************************************************************************/
+
+#ifdef RCSID
+static char RcsId[] = "@(#)$Revision$";
+#endif
+
+/* $Id$ */
+
+#include <H5private.h> /* Generic Functions */
+#include <H5Aprivate.h> /* Atom Functions */
+#include <H5Eprivate.h> /* Error handling */
+#include <H5MMprivate.h> /* Memory Management functions */
+#include <H5Oprivate.h> /*object headers */
+#include <H5Sprivate.h> /* Data-space functions */
+
+/* Interface initialization */
+#define PABLO_MASK H5S_mask
+#define INTERFACE_INIT H5S_init_interface
+static intn interface_initialize_g = FALSE;
+static herr_t H5S_init_interface(void);
+static void H5S_term_interface(void);
+
+
+/*--------------------------------------------------------------------------
+NAME
+ H5S_init_interface -- Initialize interface-specific information
+USAGE
+ herr_t H5S_init_interface()
+
+RETURNS
+ SUCCEED/FAIL
+DESCRIPTION
+ Initializes any interface-specific data or routines.
+
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_init_interface(void)
+{
+ herr_t ret_value = SUCCEED;
+ FUNC_ENTER(H5S_init_interface, FAIL);
+
+ /* Initialize the atom group for the file IDs */
+ if ((ret_value = H5A_init_group(H5_DATASPACE, H5A_DATASPACEID_HASHSIZE,
+ H5S_RESERVED_ATOMS,
+ (herr_t (*)(void *)) H5S_close)) != FAIL) {
+ ret_value = H5_add_exit(&H5S_term_interface);
+ }
+ FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5S_term_interface
+ PURPOSE
+ Terminate various H5S objects
+ USAGE
+ void H5S_term_interface()
+ RETURNS
+ SUCCEED/FAIL
+ DESCRIPTION
+ Release the atom group and any other resources allocated.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ Can't report errors...
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static void
+H5S_term_interface(void)
+{
+ H5A_destroy_group(H5_DATASPACE);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Screate_simple
+ *
+ * Purpose: Creates a new simple data space object and opens it for
+ * access. The DIMS argument is the size of the simple dataset
+ * and the MAXDIMS argument is the upper limit on the size of
+ * the dataset. MAXDIMS may be the null pointer in which case
+ * the upper limit is the same as DIMS. If an element of
+ * MAXDIMS is zero then the corresponding dimension is unlimited,
+ * otherwise no element of MAXDIMS should be smaller than the
+ * corresponding element of DIMS.
+ *
+ * Return: Success: The ID for the new simple data space object.
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ *
+ * Programmer: Quincey Koziol
+ * Tuesday, January 27, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Screate_simple(int rank, const size_t *dims, const size_t *maxdims)
+{
+ H5S_t *ds = NULL;
+ hid_t ret_value = FAIL;
+ int i;
+
+ FUNC_ENTER(H5Screate, FAIL);
+
+ /* Check arguments */
+ if (rank<0) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+ "dimensionality cannot be negative");
+ }
+ if (!dims) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+ "no dimensions specified");
+ }
+ if (maxdims) {
+ for (i=0; i<rank; i++) {
+ if (maxdims[i] && maxdims[i]<dims[i]) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+ "maxdims is smaller than dims");
+ }
+ }
+ }
+
+ /* Create a new data space */
+ ds = H5MM_xcalloc(1, sizeof(H5S_t));
+#ifdef LATER /* QAK */
+ if(rank>0) /* for creating simple dataspace */
+ {
+#endif /* LATER */
+ ds->type = H5S_SIMPLE;
+ ds->hslab_def = FALSE; /* no hyperslab defined currently */
+
+ /* Initialize rank and dimensions */
+ ds->u.simple.rank = rank;
+
+ ds->u.simple.size = H5MM_xcalloc(1, rank*sizeof(size_t));
+ HDmemcpy(ds->u.simple.size, dims, rank*sizeof(size_t));
+
+ if (maxdims) {
+ ds->u.simple.max = H5MM_xcalloc(1, rank*sizeof(size_t));
+ HDmemcpy (ds->u.simple.max, maxdims, rank*sizeof(size_t));
+ }
+#ifdef LATER /* QAK */
+ } /* end if */
+ else /* rank==0, for scalar data space */
+ {
+ ds->type = H5S_SCALAR;
+ } /* end else */
+#endif /* LATER */
+
+ /* Register the new data space and get an ID for it */
+ if ((ret_value = H5A_register(H5_DATASPACE, ds)) < 0) {
+ HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
+ "unable to register data space for ID");
+ }
+
+ done:
+ if (ret_value < 0) {
+ H5MM_xfree(ds);
+ }
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Sclose
+ *
+ * Purpose: Release access to a data space object.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Errors:
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Sclose(hid_t space_id)
+{
+ FUNC_ENTER(H5Sclose, FAIL);
+
+ /* Check args */
+ if (H5_DATASPACE != H5A_group(space_id) ||
+ NULL == H5A_object(space_id)) {
+ HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+ }
+ /* When the reference count reaches zero the resources are freed */
+ if (H5A_dec_ref(space_id) < 0) {
+ HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
+ }
+ FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_close
+ *
+ * Purpose: Releases all memory associated with a data space.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5S_close(H5S_t *ds)
+{
+ FUNC_ENTER(H5S_close, FAIL);
+
+ assert(ds);
+
+ switch (ds->type) {
+ case H5S_SCALAR:
+ /*void */
+ break;
+
+ case H5S_SIMPLE:
+ H5MM_xfree(ds->u.simple.size);
+ H5MM_xfree(ds->u.simple.max);
+ H5MM_xfree(ds->u.simple.perm);
+ break;
+
+ case H5S_COMPLEX:
+ /* nothing */
+ break;
+
+ default:
+ assert("unknown data space type" && 0);
+ break;
+ }
+ if(ds->hslab_def==TRUE) {
+ H5MM_xfree(ds->h.start);
+ H5MM_xfree(ds->h.count);
+ H5MM_xfree(ds->h.stride);
+ } /* end if */
+ H5MM_xfree(ds);
+
+ FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Scopy
+ *
+ * Purpose: Copies a dataspace.
+ *
+ * Return: Success: ID of the new dataspace
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Friday, January 30, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Scopy (hid_t space_id)
+{
+ H5S_t *src = NULL;
+ H5S_t *dst = NULL;
+ hid_t ret_value = FAIL;
+
+ FUNC_ENTER (H5Scopy, FAIL);
+
+ /* Check args */
+ if (H5_DATASPACE!=H5A_group (space_id) ||
+ NULL==(src=H5A_object (space_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+ }
+
+ /* Copy */
+ if (NULL==(dst=H5S_copy (src))) {
+ HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
+ "unable to copy data space");
+ }
+
+ /* Atomize */
+ if ((ret_value=H5A_register (H5_DATASPACE, dst))<0) {
+ HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+ "unable to register data space atom");
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_copy
+ *
+ * Purpose: Copies a data space.
+ *
+ * Return: Success: A pointer to a new copy of SRC
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 4, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5S_t *
+H5S_copy(const H5S_t *src)
+{
+ H5S_t *dst = NULL;
+ int i;
+
+ FUNC_ENTER(H5S_copy, NULL);
+
+ dst = H5MM_xmalloc(sizeof(H5S_t));
+ *dst = *src;
+
+ switch (dst->type) {
+ case H5S_SCALAR:
+ /*void */
+ break;
+
+ case H5S_SIMPLE:
+ if (dst->u.simple.size) {
+ dst->u.simple.size = H5MM_xmalloc(dst->u.simple.rank *
+ sizeof(dst->u.simple.size[0]));
+ for (i = 0; i < dst->u.simple.rank; i++) {
+ dst->u.simple.size[i] = src->u.simple.size[i];
+ }
+ }
+ if (dst->u.simple.max) {
+ dst->u.simple.max = H5MM_xmalloc(dst->u.simple.rank *
+ sizeof(dst->u.simple.max[0]));
+ for (i = 0; i < dst->u.simple.rank; i++) {
+ dst->u.simple.max[i] = src->u.simple.max[i];
+ }
+ }
+ if (dst->u.simple.perm) {
+ dst->u.simple.perm = H5MM_xmalloc(dst->u.simple.rank *
+ sizeof(dst->u.simple.perm[0]));
+ for (i = 0; i < dst->u.simple.rank; i++) {
+ dst->u.simple.perm[i] = src->u.simple.perm[i];
+ }
+ }
+ break;
+
+ case H5S_COMPLEX:
+ /*void */
+ break;
+
+ default:
+ assert("unknown data space type" && 0);
+ break;
+ }
+
+ FUNC_LEAVE(dst);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Sget_npoints
+ *
+ * Purpose: Determines how many data points a data set has.
+ *
+ * Return: Success: Number of data points in the data set.
+ *
+ * Failure: 0
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5Sget_npoints(hid_t space_id)
+{
+ H5S_t *ds = NULL;
+ size_t ret_value = 0;
+
+ FUNC_ENTER(H5Sget_npoints, 0);
+
+ /* Check args */
+ if (H5_DATASPACE != H5A_group(space_id) ||
+ NULL == (ds = H5A_object(space_id))) {
+ HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
+ }
+ ret_value = H5S_get_npoints(ds);
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_get_npoints
+ *
+ * Purpose: Determines how many data points a data set has.
+ *
+ * Return: Success: Number of data points in the data set.
+ *
+ * Failure: 0
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5S_get_npoints(const H5S_t *ds)
+{
+ size_t ret_value = 0;
+ intn i;
+
+ FUNC_ENTER(H5S_get_npoints, 0);
+
+ /* check args */
+ assert(ds);
+
+ switch (ds->type) {
+ case H5S_SCALAR:
+ ret_value = 1;
+ break;
+
+ case H5S_SIMPLE:
+ /*
+ * Count the elements selected by the hypeslab if there is one,
+ * otherwise count all the elements.
+ */
+ if (ds->hslab_def) {
+ for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
+ ret_value *= ds->h.count[i];
+ }
+ } else {
+ for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
+ ret_value *= ds->u.simple.size[i];
+ }
+ }
+ break;
+
+ case H5S_COMPLEX:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+ "complex data spaces are not supported yet");
+
+ default:
+ assert("unknown data space class" && 0);
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+ "internal error (unknown data space class)");
+ }
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Sget_ndims
+ *
+ * Purpose: Determines the dimensionality of a data space.
+ *
+ * Return: Success: The number of dimensions in a data space.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_ndims(hid_t space_id)
+{
+ H5S_t *ds = NULL;
+ intn ret_value = 0;
+
+ FUNC_ENTER(H5Sget_ndims, FAIL);
+
+ /* Check args */
+ if (H5_DATASPACE != H5A_group(space_id) ||
+ NULL == (ds = H5A_object(space_id))) {
+ HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+ }
+ ret_value = H5S_get_ndims(ds);
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_get_ndims
+ *
+ * Purpose: Returns the number of dimensions in a data space.
+ *
+ * Return: Success: Non-negative number of dimensions. Zero
+ * implies a scalar.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_ndims(const H5S_t *ds)
+{
+ intn ret_value = FAIL;
+
+ FUNC_ENTER(H5S_get_ndims, FAIL);
+
+ /* check args */
+ assert(ds);
+
+ switch (ds->type) {
+ case H5S_SCALAR:
+ ret_value = 0;
+ break;
+
+ case H5S_SIMPLE:
+ ret_value = ds->u.simple.rank;
+ break;
+
+ case H5S_COMPLEX:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "complex data spaces are not supported yet");
+
+ default:
+ assert("unknown data space class" && 0);
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "internal error (unknown data space class)");
+ }
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Sget_dims
+ *
+ * Purpose: Returns the size in each dimension of a data space DS through
+ * the DIMS argument.
+ *
+ * Return: Success: Number of dimensions, the same value as
+ * returned by H5Sget_ndims().
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_dims(hid_t space_id, size_t dims[]/*out*/)
+{
+
+ H5S_t *ds = NULL;
+ intn ret_value = 0;
+
+ FUNC_ENTER(H5Sget_dims, FAIL);
+
+ /* Check args */
+ if (H5_DATASPACE != H5A_group(space_id) ||
+ NULL == (ds = H5A_object(space_id))) {
+ HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+ }
+ if (!dims) {
+ HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
+ }
+ ret_value = H5S_get_dims(ds, dims);
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_get_dims
+ *
+ * Purpose: Returns the size in each dimension of a data space. This
+ * function may not be meaningful for all types of data spaces.
+ *
+ * Return: Success: Number of dimensions. Zero implies scalar.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_dims(const H5S_t *ds, size_t dims[])
+{
+ intn ret_value = FAIL;
+ intn i;
+
+ FUNC_ENTER(H5S_get_dims, FAIL);
+
+ /* check args */
+ assert(ds);
+ assert(dims);
+
+ switch (ds->type) {
+ case H5S_SCALAR:
+ ret_value = 0;
+ break;
+
+ case H5S_SIMPLE:
+ ret_value = ds->u.simple.rank;
+ for (i = 0; i < ret_value; i++) {
+ dims[i] = ds->u.simple.size[i];
+ }
+ break;
+
+ case H5S_COMPLEX:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "complex data spaces are not supported yet");
+
+ default:
+ assert("unknown data space class" && 0);
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "internal error (unknown data space class)");
+ }
+
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_modify
+ *
+ * Purpose: Updates a data space by writing a message to an object
+ * header.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5S_modify(H5G_entry_t *ent, const H5S_t *ds)
+{
+ FUNC_ENTER(H5S_modify, FAIL);
+
+ assert(ent);
+ assert(ds);
+
+ switch (ds->type) {
+ case H5S_SCALAR:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "scalar data spaces are not implemented yet");
+
+ case H5S_SIMPLE:
+ if (H5O_modify(ent, H5O_SDSPACE, 0, 0, &(ds->u.simple)) < 0) {
+ HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL,
+ "can't update simple data space message");
+ }
+ break;
+
+ case H5S_COMPLEX:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "complex data spaces are not implemented yet");
+
+ default:
+ assert("unknown data space class" && 0);
+ break;
+ }
+
+ FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_read
+ *
+ * Purpose: Reads the data space from an object header.
+ *
+ * Return: Success: Pointer to a new data space.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Tuesday, December 9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5S_t *
+H5S_read(H5F_t *f, H5G_entry_t *ent)
+{
+ H5S_t *ds = NULL;
+
+ FUNC_ENTER(H5S_read, NULL);
+
+ /* check args */
+ assert(f);
+ assert(ent);
+
+ ds = H5MM_xcalloc(1, sizeof(H5S_t));
+
+ if (H5O_read(ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
+ ds->type = H5S_SIMPLE;
+
+ } else {
+ ds->type = H5S_SCALAR;
+ }
+
+ FUNC_LEAVE(ds);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_cmp
+ *
+ * Purpose: Compares two data spaces.
+ *
+ * Return: Success: 0 if DS1 and DS2 are the same.
+ * <0 if DS1 is less than DS2.
+ * >0 if DS1 is greater than DS2.
+ *
+ * Failure: 0, never fails
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, December 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_cmp(const H5S_t *ds1, const H5S_t *ds2)
+{
+ intn i;
+
+ FUNC_ENTER(H5S_cmp, 0);
+
+ /* check args */
+ assert(ds1);
+ assert(ds2);
+
+ /* compare */
+ if (ds1->type < ds2->type)
+ HRETURN(-1);
+ if (ds1->type > ds2->type)
+ HRETURN(1);
+
+ switch (ds1->type) {
+ case H5S_SIMPLE:
+ if (ds1->u.simple.rank < ds2->u.simple.rank)
+ HRETURN(-1);
+ if (ds1->u.simple.rank > ds2->u.simple.rank)
+ HRETURN(1);
+
+ for (i = 0; i < ds1->u.simple.rank; i++) {
+ if (ds1->u.simple.size[i] < ds2->u.simple.size[i])
+ HRETURN(-1);
+ if (ds1->u.simple.size[i] > ds2->u.simple.size[i])
+ HRETURN(1);
+ }
+
+ /* don't compare max dimensions */
+
+ for (i = 0; i < ds1->u.simple.rank; i++) {
+ if ((ds1->u.simple.perm ? ds1->u.simple.perm[i] : i) <
+ (ds2->u.simple.perm ? ds2->u.simple.perm[i] : i))
+ HRETURN(-1);
+ if ((ds1->u.simple.perm ? ds2->u.simple.perm[i] : i) >
+ (ds2->u.simple.perm ? ds2->u.simple.perm[i] : i))
+ HRETURN(1);
+ }
+
+ /* Check if we should compare hyperslab definitions */
+ if(ds1->hslab_def==TRUE && ds2->hslab_def==TRUE) {
+ for (i = 0; i < ds1->u.simple.rank; i++) {
+ if (ds1->h.start[i] < ds2->h.start[i])
+ HRETURN(-1);
+ if (ds1->h.start[i] > ds2->h.start[i])
+ HRETURN(1);
+ if (ds1->h.count[i] < ds2->h.count[i])
+ HRETURN(-1);
+ if (ds1->h.count[i] > ds2->h.count[i])
+ HRETURN(1);
+ if (ds1->h.stride[i] < ds2->h.stride[i])
+ HRETURN(-1);
+ if (ds1->h.stride[i] > ds2->h.stride[i])
+ HRETURN(1);
+ }
+ } else {
+ if(ds1->hslab_def!=ds2->hslab_def)
+ HRETURN(ds1->hslab_def==TRUE ? 1 : -1);
+ }
+
+ break;
+
+ default:
+ assert("not implemented yet" && 0);
+ }
+
+ FUNC_LEAVE(0);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5S_is_simple
+ PURPOSE
+ Check if a dataspace is simple (internal)
+ USAGE
+ hbool_t H5S_is_simple(sdim)
+ H5S_t *sdim; IN: Pointer to dataspace object to query
+ RETURNS
+ TRUE/FALSE/FAIL
+ DESCRIPTION
+ This function determines the if a dataspace is "simple". ie. if it
+ has orthogonal, evenly spaced dimensions.
+--------------------------------------------------------------------------*/
+hbool_t
+H5S_is_simple(const H5S_t *sdim)
+{
+ hbool_t ret_value = FAIL;
+
+ FUNC_ENTER(H5S_is_simple, FAIL);
+
+ /* Check args and all the boring stuff. */
+ assert(sdim);
+ ret_value = sdim->type == H5S_SIMPLE ? TRUE : FALSE; /* Currently all dataspaces are simple, but check anyway */
+
+ FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5Sis_simple
+ PURPOSE
+ Check if a dataspace is simple
+ USAGE
+ hbool_t H5Sis_simple(sid)
+ hid_t sid; IN: ID of dataspace object to query
+ RETURNS
+ TRUE/FALSE/FAIL
+ DESCRIPTION
+ This function determines the if a dataspace is "simple". ie. if it
+ has orthogonal, evenly spaced dimensions.
+--------------------------------------------------------------------------*/
+hbool_t
+H5Sis_simple(hid_t sid)
+{
+ H5S_t *space = NULL; /* dataspace to modify */
+ hbool_t ret_value = FAIL;
+
+ FUNC_ENTER(H5Sis_simple, FAIL);
+
+ /* Check args and all the boring stuff. */
+ if ((space = H5A_object(sid)) == NULL)
+ HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+
+ ret_value = H5S_is_simple(space);
+
+ done:
+ if (ret_value == FAIL) { /* Error condition cleanup */
+
+ } /* end if */
+ /* Normal function cleanup */
+ FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5Sset_space
+ PURPOSE
+ Determine the size of a dataspace
+ USAGE
+ herr_t H5Sset_space(sid, rank, dims)
+ hid_t sid; IN: Dataspace object to query
+ intn rank; IN: # of dimensions for the dataspace
+ const size_t *dims; IN: Size of each dimension for the dataspace
+ RETURNS
+ SUCCEED/FAIL
+ DESCRIPTION
+ This function sets the number and size of each dimension in the
+ dataspace. Setting RANK to a value of zero allows scalar objects to be
+ created. Dimensions are specified from slowest to fastest changing in the
+ DIMS array (i.e. 'C' order). Setting the size of a dimension to zero
+ indicates that the dimension is of unlimited size and should be allowed to
+ expand. Currently, only the first dimension in the array (the slowest) may
+ be unlimited in size.
+--------------------------------------------------------------------------*/
+herr_t
+H5Sset_space(hid_t sid, int rank, const size_t *dims)
+{
+ H5S_t *space = NULL; /* dataspace to modify */
+ intn u; /* local counting variable */
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER(H5Sset_space, FAIL);
+
+ /* Check args */
+ if ((space = H5A_object(sid)) == NULL)
+ HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+ if (rank > 0 && dims == NULL)
+ HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no dimensions specified");
+ if (rank<0)
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid rank");
+ if (dims) {
+ for (u=0; u<rank; u++) {
+ if (dims[u]<=0) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+ "invalid dimension size");
+ }
+ }
+ }
+
+ /* shift out of the previous state to a "simple" dataspace */
+ switch (space->type) {
+ case H5S_SCALAR:
+ case H5S_SIMPLE:
+ /* do nothing */
+ break;
+
+ case H5S_COMPLEX:
+ /*
+ * eventually this will destroy whatever "complex" dataspace info
+ * is retained, right now it's an error
+ */
+ /* Fall through to report error */
+
+ default:
+ HRETURN_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+ "unknown data space class");
+ }
+ space->type = H5S_SIMPLE;
+
+ /* Reset hyperslab definition, if one is defined */
+ if(space->hslab_def==TRUE) {
+ H5MM_xfree(space->h.start);
+ H5MM_xfree(space->h.count);
+ H5MM_xfree(space->h.stride);
+ space->hslab_def=FALSE;
+ }
+
+ if (rank == 0) { /* scalar variable */
+ space->type = H5S_SCALAR;
+ space->u.simple.rank = 0; /* set to scalar rank */
+ if (space->u.simple.size != NULL)
+ space->u.simple.size = H5MM_xfree(space->u.simple.size);
+ if (space->u.simple.max != NULL)
+ space->u.simple.max = H5MM_xfree(space->u.simple.max);
+ if (space->u.simple.perm != NULL)
+ space->u.simple.max = H5MM_xfree(space->u.simple.perm);
+ } else {
+ /* Free the old space for now */
+ if (space->u.simple.size != NULL)
+ space->u.simple.size = H5MM_xfree(space->u.simple.size);
+ if (space->u.simple.max != NULL)
+ space->u.simple.max = H5MM_xfree(space->u.simple.max);
+ if (space->u.simple.perm != NULL)
+ space->u.simple.perm = H5MM_xfree(space->u.simple.perm);
+
+ /* Set the rank and copy the dims */
+ space->u.simple.rank = rank;
+ space->u.simple.size = H5MM_xcalloc(rank, sizeof(size_t));
+ HDmemcpy(space->u.simple.size, dims, sizeof(size_t) * rank);
+
+ }
+ FUNC_LEAVE(ret_value);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5Sset_hyperslab
+ PURPOSE
+ Select a hyperslab from a simple dataspace
+ USAGE
+ herr_t H5Sset_hyperslab(sid, start, count, stride)
+ hid_t sid; IN: Dataspace object to select hyperslab from
+ const int *start; IN: Starting location for hyperslab to select
+ const size_t *count; IN: Number of elements in hyperslab
+ const size_t *stride; IN: Packing of elements in hyperslab
+ RETURNS
+ SUCCEED/FAIL
+ DESCRIPTION
+ This function selects a hyperslab from a simple dataspace. The stride
+ array may be used to sub-sample the hyperslab chosen, a value of 1 in each
+ position of the stride array selects contiguous elements in the array,
+ a value of 2 selects every other element, etc. If the stride parameter is
+ set to NULL, a contiguous hyperslab is chosen. The values in the start and
+ count arrays may be negative, to allow for selecting hyperslabs in chunked
+ datasets which extend in arbitrary directions.
+--------------------------------------------------------------------------*/
+herr_t
+H5Sset_hyperslab(hid_t sid, const int *start, const size_t *count, const size_t *stride)
+{
+ H5S_t *space = NULL; /* dataspace to modify */
+ size_t *tmp_stride=NULL; /* temp. copy of stride */
+ intn u; /* local counting variable */
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER(H5Sset_hyperslab, FAIL);
+
+ /* Get the object */
+ if (H5_DATASPACE != H5A_group(sid) || (space = H5A_object(sid)) == NULL)
+ HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+ if (start == NULL || count==NULL)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+ "invalid hyperslab selected");
+
+ /* We can't modify other types of dataspaces currently, so error out */
+ if (space->type!=H5S_SIMPLE)
+ HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+ "unknown dataspace type");
+
+ /* Set up stride values for later use */
+ tmp_stride= H5MM_xmalloc(space->u.simple.rank*sizeof(tmp_stride[0]));
+ for (u=0; u<space->u.simple.rank; u++) {
+ tmp_stride[u] = stride ? stride[u] : 1;
+ }
+
+ /* Range check arguments */
+ for (u=0; u<space->u.simple.rank; u++) {
+ if (start[u]<0 || start[u]>=space->u.simple.size[u]) {
+ HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+ "hyperslab bounds out of range");
+ }
+ if (start[u]<0 ||
+ start[u]+(count[u]*tmp_stride[u])>space->u.simple.size[u]) {
+ HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+ "hyperslab bounds out of range");
+ }
+ }
+
+ /* Allocate space for the hyperslab information */
+ if (NULL==space->h.start) {
+ space->h.start= H5MM_xcalloc(space->u.simple.rank,sizeof(intn));
+ space->h.count= H5MM_xcalloc(space->u.simple.rank,sizeof(size_t));
+ space->h.stride= H5MM_xcalloc(space->u.simple.rank,sizeof(size_t));
+ }
+
+ /* Build hyperslab */
+ for(u=0; u<space->u.simple.rank; u++) {
+ space->h.start[u] = start[u];
+ space->h.count[u] = count[u];
+ space->h.stride[u] = tmp_stride[u];
+ }
+ space->hslab_def=TRUE;
+
+done:
+ if (ret_value == FAIL) { /* Error condition cleanup */
+
+ } /* end if */
+
+ /* Normal function cleanup */
+ H5MM_xfree(tmp_stride);
+ FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Sget_hyperslab
+ *
+ * Purpose: Retrieves information about the hyperslab from a simple data
+ * space. If no hyperslab has been defined then the hyperslab
+ * is the same as the entire array.
+ *
+ * Return: Success: Hyperslab dimensionality.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, January 28, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_hyperslab (hid_t sid, int offset[]/*out*/, size_t size[]/*out*/,
+ size_t stride[]/*out*/)
+{
+ const H5S_t *ds = NULL;
+ intn ret_value = FAIL;
+
+ FUNC_ENTER (H5Sget_hyperslab, FAIL);
+
+ /* Check args */
+ if (H5_DATASPACE!=H5A_group (sid) || NULL==(ds=H5A_object (sid))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+ }
+
+ /* Get hyperslab info */
+ if ((ret_value=H5S_get_hyperslab (ds, offset, size, stride))<0) {
+ HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
+ "unable to retrieve hyperslab information");
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_get_hyperslab
+ *
+ * Purpose: Retrieves information about the hyperslab from a simple data
+ * space. If no hyperslab has been defined then the hyperslab
+ * is the same as the entire array.
+ *
+ * Return: Success: Hyperslab dimensionality.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, January 28, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_hyperslab (const H5S_t *ds, int offset[]/*out*/,
+ size_t size[]/*out*/, size_t stride[]/*out*/)
+{
+ intn i;
+ intn ret_value = FAIL;
+
+ FUNC_ENTER (H5S_get_hyperslab, FAIL);
+
+ /* Check args */
+ assert (ds);
+ switch (ds->type) {
+ case H5S_SCALAR:
+ break;
+
+ case H5S_SIMPLE:
+ if (ds->hslab_def) {
+ for (i=0; i<ds->u.simple.rank; i++) {
+ if (offset) offset[i] = ds->h.start[i];
+ if (size) size[i] = ds->h.count[i];
+ if (stride) stride[i] = ds->h.stride[i];
+ }
+ } else {
+ for (i=0; i<ds->u.simple.rank; i++) {
+ if (offset) offset[i] = 0;
+ if (size) size[i] = ds->u.simple.size[i];
+ if (stride) stride[i] = 1;
+ }
+ }
+ ret_value = ds->u.simple.rank;
+ break;
+
+ case H5S_COMPLEX: /*fall through*/
+ default:
+ HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+ "hyperslabs not supported for this type of space");
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_find
+ *
+ * Purpose: Given two data spaces (MEM_SPACE and FILE_SPACE) this
+ * function locates the data space conversion functions and
+ * initializes CONV to point to them. The CONV contains
+ * function pointers for converting in either direction.
+ *
+ * Return: Success: Pointer to a data space conversion callback
+ * list.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, January 21, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const H5S_conv_t *
+H5S_find (const H5S_t *mem_space, const H5S_t *file_space)
+{
+ static H5S_conv_t _conv;
+ static const H5S_conv_t *conv = NULL;
+
+ FUNC_ENTER (H5S_find, NULL);
+
+ /* Check args */
+ assert (mem_space && H5S_SIMPLE==mem_space->type);
+ assert (file_space && H5S_SIMPLE==file_space->type);
+
+ /*
+ * We can't do conversion if the source and destination select a
+ * different number of data points.
+ */
+ if (H5S_get_npoints (mem_space) != H5S_get_npoints (file_space)) {
+ HRETURN_ERROR (H5E_DATASPACE, H5E_BADRANGE, NULL,
+ "memory and file data spaces are different sizes");
+ }
+
+ /*
+ * Initialize pointers. This will eventually be a table lookup based
+ * on the source and destination data spaces, similar to H5T_find(), but
+ * for now we only support simple data spaces.
+ */
+ if (!conv) {
+ _conv.init = H5S_simp_init;
+ _conv.fgath = H5S_simp_fgath;
+ _conv.mscat = H5S_simp_mscat;
+ _conv.mgath = H5S_simp_mgath;
+ _conv.fscat = H5S_simp_fscat;
+ conv = &_conv;
+ }
+
+ FUNC_LEAVE (conv);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5S_extend
+ *
+ * Purpose: Extend the dimensions of a data space.
+ *
+ * Return: Success: Number of dimensions whose size increased.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Friday, January 30, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_extend (H5S_t *space, const size_t *size)
+{
+ intn i, ret_value=0;
+
+ FUNC_ENTER (H5S_extend, FAIL);
+
+ /* Check args */
+ assert (space && H5S_SIMPLE==space->type);
+ assert (size);
+
+ for (i=0; i<space->u.simple.rank; i++) {
+ if (space->u.simple.size[i]<size[i]) {
+ if (space->u.simple.max &&
+ H5S_UNLIMITED!=space->u.simple.max[i] &&
+ space->u.simple.max[i]<size[i]) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+ "dimension cannot be increased");
+ }
+ ret_value++;
+ }
+ }
+
+ /* Update */
+ if (ret_value) {
+ for (i=0; i<space->u.simple.rank; i++) {
+ if (space->u.simple.size[i]<size[i]) {
+ space->u.simple.size[i] = size[i];
+ }
+ }
+ }
+
+ FUNC_LEAVE (ret_value);
+}
+