1998-07-06 16:01:13 -05:00
|
|
|
|
/*
|
2001-04-05 12:29:14 -05:00
|
|
|
|
* Copyright (C) 1998-2001 NCSA
|
|
|
|
|
* All rights reserved.
|
1998-07-06 16:01:13 -05:00
|
|
|
|
*
|
|
|
|
|
* Programmer: Quincey Koziol <koziol@ncsa.uiuc.ued>
|
|
|
|
|
* Friday, May 29, 1998
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Dataspace functions.
|
|
|
|
|
*/
|
|
|
|
|
|
2000-10-10 02:43:38 -05:00
|
|
|
|
#define H5S_PACKAGE /*suppress error about including H5Spkg */
|
|
|
|
|
|
2001-04-05 12:29:14 -05:00
|
|
|
|
#include "H5private.h"
|
|
|
|
|
#include "H5Eprivate.h"
|
|
|
|
|
#include "H5FLprivate.h" /*Free Lists */
|
|
|
|
|
#include "H5Iprivate.h"
|
|
|
|
|
#include "H5MMprivate.h"
|
|
|
|
|
#include "H5Spkg.h"
|
|
|
|
|
#include "H5Vprivate.h"
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
/* Interface initialization */
|
1999-04-14 16:48:05 -05:00
|
|
|
|
#define PABLO_MASK H5Sselect_mask
|
1998-11-20 22:36:51 -05:00
|
|
|
|
#define INTERFACE_INIT NULL
|
2001-08-14 17:09:56 -05:00
|
|
|
|
static int interface_initialize_g = 0;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
static hssize_t H5S_get_select_hyper_nblocks(H5S_t *space);
|
|
|
|
|
static hssize_t H5S_get_select_elem_npoints(H5S_t *space);
|
1999-03-11 16:03:30 -05:00
|
|
|
|
static herr_t H5S_get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks, hsize_t *buf);
|
|
|
|
|
static herr_t H5S_get_select_elem_pointlist(H5S_t *space, hsize_t startpoint, hsize_t numpoints, hsize_t *buf);
|
|
|
|
|
static herr_t H5S_get_select_bounds(H5S_t *space, hsize_t *start, hsize_t *end);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
2000-04-04 16:00:31 -05:00
|
|
|
|
/* Declare external the free list for hssize_t arrays */
|
|
|
|
|
H5FL_ARR_EXTERN(hssize_t);
|
|
|
|
|
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_copy
|
|
|
|
|
PURPOSE
|
|
|
|
|
Copy a selection from one dataspace to another
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_copy(dst, src)
|
|
|
|
|
H5S_t *dst; OUT: Pointer to the destination dataspace
|
|
|
|
|
H5S_t *src; IN: Pointer to the source dataspace
|
|
|
|
|
RETURNS
|
1998-10-26 16:18:54 -05:00
|
|
|
|
Non-negative on success/Negative on failure
|
1998-07-06 16:01:13 -05:00
|
|
|
|
DESCRIPTION
|
|
|
|
|
Copies all the selection information (include offset) from the source
|
|
|
|
|
dataspace to the destination dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
1998-07-08 10:05:01 -05:00
|
|
|
|
herr_t
|
|
|
|
|
H5S_select_copy (H5S_t *dst, const H5S_t *src)
|
1998-07-06 16:01:13 -05:00
|
|
|
|
{
|
1998-07-22 17:11:22 -05:00
|
|
|
|
herr_t ret_value=SUCCEED; /* return value */
|
|
|
|
|
|
1998-07-06 16:01:13 -05:00
|
|
|
|
FUNC_ENTER (H5S_select_copy, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert(dst);
|
|
|
|
|
assert(src);
|
|
|
|
|
|
1998-07-22 17:11:22 -05:00
|
|
|
|
/* Copy regular fields */
|
|
|
|
|
dst->select=src->select;
|
|
|
|
|
|
1998-08-03 19:30:35 -05:00
|
|
|
|
/* Need to copy order information still */
|
|
|
|
|
|
|
|
|
|
/* Copy offset information */
|
2001-06-21 11:53:39 -05:00
|
|
|
|
if (NULL==(dst->select.offset = H5FL_ARR_ALLOC(hssize_t,src->extent.u.simple.rank,1))) {
|
1998-08-06 14:39:22 -05:00
|
|
|
|
HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
|
|
|
|
|
"memory allocation failed");
|
1998-08-03 19:30:35 -05:00
|
|
|
|
}
|
|
|
|
|
if(src->select.offset!=NULL)
|
|
|
|
|
HDmemcpy(dst->select.offset,src->select.offset,(src->extent.u.simple.rank*sizeof(hssize_t)));
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
/* Perform correct type of copy based on the type of selection */
|
1998-07-22 17:11:22 -05:00
|
|
|
|
switch (src->extent.type) {
|
|
|
|
|
case H5S_SCALAR:
|
|
|
|
|
/*nothing needed */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SIMPLE:
|
|
|
|
|
/* Deep copy extra stuff */
|
|
|
|
|
switch(src->select.type) {
|
|
|
|
|
case H5S_SEL_NONE:
|
|
|
|
|
case H5S_SEL_ALL:
|
|
|
|
|
/*nothing needed */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_POINTS:
|
|
|
|
|
ret_value=H5S_point_copy(dst,src);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS:
|
|
|
|
|
ret_value=H5S_hyper_copy(dst,src);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
assert("unknown selection type" && 0);
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_COMPLEX:
|
|
|
|
|
/*void */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
assert("unknown data space type" && 0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-10-21 00:09:58 -05:00
|
|
|
|
FUNC_LEAVE (ret_value);
|
1998-07-06 16:01:13 -05:00
|
|
|
|
} /* H5S_select_copy() */
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_release
|
|
|
|
|
PURPOSE
|
|
|
|
|
Release selection information for a dataspace
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_release(space)
|
|
|
|
|
H5S_t *space; IN: Pointer to dataspace
|
|
|
|
|
RETURNS
|
1998-10-26 16:18:54 -05:00
|
|
|
|
Non-negative on success/Negative on failure
|
1998-07-06 16:01:13 -05:00
|
|
|
|
DESCRIPTION
|
|
|
|
|
Releases all selection information for a dataspace
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5S_select_release (H5S_t *space)
|
|
|
|
|
{
|
1998-07-15 16:23:25 -05:00
|
|
|
|
herr_t ret_value=SUCCEED; /* return value */
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_release, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert (space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_release(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_release(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_release(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
}
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-08-25 15:46:17 -05:00
|
|
|
|
/* Reset type of selection to "all" */
|
|
|
|
|
space->select.type=H5S_SEL_ALL;
|
|
|
|
|
|
1998-07-07 17:14:28 -05:00
|
|
|
|
FUNC_LEAVE (ret_value);
|
1998-07-06 16:01:13 -05:00
|
|
|
|
} /* H5S_select_release() */
|
1998-07-23 18:29:44 -05:00
|
|
|
|
|
1998-07-24 15:46:19 -05:00
|
|
|
|
|
1998-07-06 16:01:13 -05:00
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
1998-08-31 22:35:23 -05:00
|
|
|
|
H5Sget_select_npoints
|
1998-07-06 16:01:13 -05:00
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of elements in current selection
|
|
|
|
|
USAGE
|
1998-10-26 12:42:48 -05:00
|
|
|
|
hssize_t H5Sget_select_npoints(dsid)
|
1998-07-06 16:01:13 -05:00
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of elements in selection on success, 0 on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of elements in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
1998-10-26 12:42:48 -05:00
|
|
|
|
hssize_t
|
1998-08-31 22:35:23 -05:00
|
|
|
|
H5Sget_select_npoints(hid_t spaceid)
|
1998-07-06 16:01:13 -05:00
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
1998-10-26 12:42:48 -05:00
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-08-31 22:35:23 -05:00
|
|
|
|
FUNC_ENTER (H5Sget_select_npoints, 0);
|
1998-10-26 14:55:54 -05:00
|
|
|
|
H5TRACE1("Hs","i",spaceid);
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
1998-10-05 18:41:30 -05:00
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
1998-07-06 16:01:13 -05:00
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
ret_value = H5S_get_select_npoints(space);
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
1998-08-31 22:35:23 -05:00
|
|
|
|
} /* H5Sget_select_npoints() */
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
1998-09-02 16:16:24 -05:00
|
|
|
|
H5S_get_select_npoints
|
1998-07-06 16:01:13 -05:00
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of elements in current selection
|
|
|
|
|
USAGE
|
2001-06-18 15:22:10 -05:00
|
|
|
|
herr_t H5S_get_select_npoints(ds)
|
1998-07-06 16:01:13 -05:00
|
|
|
|
H5S_t *ds; IN: Dataspace pointer
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of elements in selection on success, 0 on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of elements in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
1998-10-26 12:42:48 -05:00
|
|
|
|
hssize_t
|
1998-09-02 16:16:24 -05:00
|
|
|
|
H5S_get_select_npoints (const H5S_t *space)
|
1998-07-06 16:01:13 -05:00
|
|
|
|
{
|
1998-10-26 12:42:48 -05:00
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
FUNC_ENTER (H5S_get_select_npoints, FAIL);
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_npoints(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_npoints(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_npoints(space);
|
|
|
|
|
break;
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=0;
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
}
|
1998-07-06 16:01:13 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
1998-09-02 16:16:24 -05:00
|
|
|
|
} /* H5S_get_select_npoints() */
|
1998-07-07 17:14:28 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_sel_iter_release
|
|
|
|
|
PURPOSE
|
|
|
|
|
Release selection iterator information for a dataspace
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_sel_iter_release(sel_iter)
|
|
|
|
|
const H5S_t *space; IN: Pointer to dataspace iterator is for
|
|
|
|
|
H5S_sel_iter_t *sel_iter; IN: Pointer to selection iterator
|
|
|
|
|
RETURNS
|
1998-10-26 16:18:54 -05:00
|
|
|
|
Non-negative on success/Negative on failure
|
1998-07-07 17:14:28 -05:00
|
|
|
|
DESCRIPTION
|
|
|
|
|
Releases all information for a dataspace selection iterator
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5S_sel_iter_release (const H5S_t *space, H5S_sel_iter_t *sel_iter)
|
|
|
|
|
{
|
1998-07-15 16:23:25 -05:00
|
|
|
|
herr_t ret_value=SUCCEED; /* Return value */
|
1998-07-07 17:14:28 -05:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_sel_iter_release, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert (sel_iter);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
/* no action needed */
|
|
|
|
|
ret_value=SUCCEED;
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_sel_iter_release(sel_iter);
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
|
1998-09-02 16:16:24 -05:00
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
}
|
1998-07-07 17:14:28 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_sel_iter_release() */
|
1998-08-03 19:30:35 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sselect_valid
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check whether the selection fits within the extent, with the current
|
|
|
|
|
offset defined.
|
|
|
|
|
USAGE
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t H5Sselect_void(dsid)
|
1998-08-03 19:30:35 -05:00
|
|
|
|
hid_t dsid; IN: Dataspace ID to query
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE if the selection fits within the extent, FALSE if it does not and
|
1998-10-26 16:18:54 -05:00
|
|
|
|
Negative on an error.
|
1998-08-03 19:30:35 -05:00
|
|
|
|
DESCRIPTION
|
|
|
|
|
Determines if the current selection at the current offet fits within the
|
|
|
|
|
extent for the dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t
|
1998-08-27 11:48:50 -05:00
|
|
|
|
H5Sselect_valid(hid_t spaceid)
|
1998-08-03 19:30:35 -05:00
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t ret_value=FAIL; /* return value */
|
1998-08-03 19:30:35 -05:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sselect_valid, 0);
|
|
|
|
|
H5TRACE1("b","i",spaceid);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
1998-10-05 18:41:30 -05:00
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
1998-08-03 19:30:35 -05:00
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret_value = H5S_select_valid(space);
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sselect_valid() */
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_valid
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check whether the selection fits within the extent, with the current
|
|
|
|
|
offset defined.
|
|
|
|
|
USAGE
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t H5Sselect_void(space)
|
1998-08-03 19:30:35 -05:00
|
|
|
|
H5S_t *space; IN: Dataspace pointer to query
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE if the selection fits within the extent, FALSE if it does not and
|
1998-10-26 16:18:54 -05:00
|
|
|
|
Negative on an error.
|
1998-08-03 19:30:35 -05:00
|
|
|
|
DESCRIPTION
|
|
|
|
|
Determines if the current selection at the current offet fits within the
|
|
|
|
|
extent for the dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t
|
1998-08-03 19:30:35 -05:00
|
|
|
|
H5S_select_valid (const H5S_t *space)
|
|
|
|
|
{
|
1998-10-26 17:44:13 -05:00
|
|
|
|
htri_t ret_value=FAIL; /* return value */
|
1998-08-03 19:30:35 -05:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_valid, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_valid(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_valid(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=TRUE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
1998-08-27 11:48:50 -05:00
|
|
|
|
}
|
1998-08-03 19:30:35 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_valid() */
|
1998-11-12 19:28:29 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_serial_size
|
|
|
|
|
PURPOSE
|
|
|
|
|
Determine the number of bytes needed to serialize the current selection
|
|
|
|
|
offset defined.
|
|
|
|
|
USAGE
|
|
|
|
|
hssize_t H5S_select_serial_size(space)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of bytes required on success, negative on an error.
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Determines the number of bytes required to serialize the current selection
|
|
|
|
|
information for storage on disk. This routine just hands off to the
|
|
|
|
|
appropriate routine for each type of selection.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
hssize_t
|
|
|
|
|
H5S_select_serial_size (const H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_serial_size, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
2001-11-02 15:31:35 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_serial_size(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_serial_size(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=16; /* replace with real function call at some point */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
1998-11-12 19:28:29 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_serial_size() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1998-11-12 19:28:29 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_serialize
|
|
|
|
|
PURPOSE
|
|
|
|
|
Serialize the current selection into a user-provided buffer.
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_serialize(space, buf)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer of selection to serialize
|
|
|
|
|
uint8 *buf; OUT: Buffer to put serialized selection into
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success/Negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Serializes the current selection into a buffer. (Primarily for storing
|
|
|
|
|
on disk). This routine just hands off to the appropriate routine for each
|
|
|
|
|
type of selection.
|
|
|
|
|
The serialized information for all types of selections follows this format:
|
|
|
|
|
<type of selection> = uint32
|
|
|
|
|
<version #> = uint32
|
|
|
|
|
<padding, not-used> = 4 bytes
|
|
|
|
|
<length of selection specific information> = uint32
|
|
|
|
|
<selection specific information> = ? bytes (depends on selection type)
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
1998-11-18 13:40:09 -05:00
|
|
|
|
H5S_select_serialize (const H5S_t *space, uint8_t *buf)
|
1998-11-12 19:28:29 -05:00
|
|
|
|
{
|
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_serialize, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_serialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_serialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_select_serialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=H5S_none_select_serialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_serialize() */
|
1998-11-24 19:29:09 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_deserialize
|
|
|
|
|
PURPOSE
|
|
|
|
|
Deserialize the current selection from a user-provided buffer into a real
|
|
|
|
|
selection in the dataspace.
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_deserialize(space, buf)
|
|
|
|
|
H5S_t *space; IN/OUT: Dataspace pointer to place selection into
|
|
|
|
|
uint8 *buf; IN: Buffer to retrieve serialized selection from
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success/Negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Deserializes the current selection into a buffer. (Primarily for retrieving
|
|
|
|
|
from disk). This routine just hands off to the appropriate routine for each
|
|
|
|
|
type of selection. The format of the serialized information is shown in
|
|
|
|
|
the H5S_select_serialize() header.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5S_select_deserialize (H5S_t *space, const uint8_t *buf)
|
|
|
|
|
{
|
1999-03-22 20:50:59 -05:00
|
|
|
|
const uint8_t *tbuf; /* Temporary pointer to the selection type */
|
|
|
|
|
uint32_t sel_type; /* Pointer to the selection type */
|
1998-11-24 19:29:09 -05:00
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_deserialize, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
1999-03-22 20:50:59 -05:00
|
|
|
|
tbuf=buf;
|
|
|
|
|
UINT32DECODE(tbuf, sel_type);
|
|
|
|
|
switch(sel_type) {
|
1998-11-24 19:29:09 -05:00
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_deserialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_deserialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_select_deserialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=H5S_none_select_deserialize(space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
2001-01-09 16:22:30 -05:00
|
|
|
|
default:
|
1998-11-24 19:29:09 -05:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_deserialize() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_get_select_hyper_nblocks
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of hyperslab blocks in current hyperslab selection
|
|
|
|
|
USAGE
|
|
|
|
|
hssize_t H5S_get_select_hyper_nblocks(space)
|
|
|
|
|
H5S_t *space; IN: Dataspace ptr of selection to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of hyperslab blocks in selection on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of hyperslab blocks in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
static hssize_t
|
|
|
|
|
H5S_get_select_hyper_nblocks(H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
2001-08-14 17:09:56 -05:00
|
|
|
|
unsigned u; /* Counter */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_get_select_hyper_nblocks, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
2000-09-13 16:58:18 -05:00
|
|
|
|
/* Check for a "regular" hyperslab selection */
|
|
|
|
|
if(space->select.sel_info.hslab.diminfo != NULL) {
|
|
|
|
|
/* Check each dimension */
|
2001-01-09 16:22:30 -05:00
|
|
|
|
for(ret_value=1,u=0; u<space->extent.u.simple.rank; u++)
|
|
|
|
|
ret_value*=space->select.sel_info.hslab.app_diminfo[u].count;
|
2000-09-13 16:58:18 -05:00
|
|
|
|
} /* end if */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
else
|
|
|
|
|
ret_value = H5S_hyper_span_nblocks(space->select.sel_info.hslab.span_lst);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
2001-11-02 15:31:35 -05:00
|
|
|
|
} /* H5S_get_select_hyper_nblocks() */
|
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_hyper_nblocks
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of hyperslab blocks in current hyperslab selection
|
|
|
|
|
USAGE
|
|
|
|
|
hssize_t H5Sget_select_hyper_nblocks(dsid)
|
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of hyperslab blocks in selection on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of hyperslab blocks in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
hssize_t
|
|
|
|
|
H5Sget_select_hyper_nblocks(hid_t spaceid)
|
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sget_select_hyper_nblocks, FAIL);
|
1999-03-12 13:35:04 -05:00
|
|
|
|
H5TRACE1("Hs","i",spaceid);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
if(space->select.type!=H5S_SEL_HYPERSLABS)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection");
|
|
|
|
|
|
|
|
|
|
ret_value = H5S_get_select_hyper_nblocks(space);
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_hyper_nblocks() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_get_select_elem_npoints
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of points in current element selection
|
|
|
|
|
USAGE
|
|
|
|
|
hssize_t H5S_get_select_elem_npoints(space)
|
|
|
|
|
H5S_t *space; IN: Dataspace ptr of selection to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of element points in selection on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of element points in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
static hssize_t
|
|
|
|
|
H5S_get_select_elem_npoints(H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_get_select_elem_npoints, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
ret_value = space->select.num_elem;
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_elem_npoints() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_elem_npoints
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the number of points in current element selection
|
|
|
|
|
USAGE
|
|
|
|
|
hssize_t H5Sget_select_elem_npoints(dsid)
|
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
|
|
|
|
RETURNS
|
|
|
|
|
The number of element points in selection on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Returns the number of element points in current selection for dataspace.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
hssize_t
|
|
|
|
|
H5Sget_select_elem_npoints(hid_t spaceid)
|
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
|
|
|
|
hssize_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sget_select_elem_npoints, FAIL);
|
1999-03-12 13:35:04 -05:00
|
|
|
|
H5TRACE1("Hs","i",spaceid);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
if(space->select.type!=H5S_SEL_POINTS)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an element selection");
|
|
|
|
|
|
|
|
|
|
ret_value = H5S_get_select_elem_npoints(space);
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_elem_npoints() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_get_select_hyper_blocklist
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the list of hyperslab blocks currently selected
|
|
|
|
|
USAGE
|
2001-11-02 15:31:35 -05:00
|
|
|
|
herr_t H5S_get_select_hyper_blocklist(space, startblock, numblocks, buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
H5S_t *space; IN: Dataspace pointer of selection to query
|
1999-03-11 16:03:30 -05:00
|
|
|
|
hsize_t startblock; IN: Hyperslab block to start with
|
|
|
|
|
hsize_t numblocks; IN: Number of hyperslab blocks to get
|
1999-03-10 18:50:03 -05:00
|
|
|
|
hsize_t *buf; OUT: List of hyperslab blocks selected
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
1999-03-12 15:05:43 -05:00
|
|
|
|
Puts a list of the hyperslab blocks into the user's buffer. The blocks
|
|
|
|
|
start with the 'startblock'th block in the list of blocks and put
|
|
|
|
|
'numblocks' number of blocks into the user's buffer (or until the end of
|
2001-11-02 15:31:35 -05:00
|
|
|
|
the list of blocks, whichever happens first)
|
1999-03-12 15:05:43 -05:00
|
|
|
|
The block coordinates have the same dimensionality (rank) as the
|
|
|
|
|
dataspace they are located within. The list of blocks is formatted as
|
|
|
|
|
follows: <"start" coordinate> immediately followed by <"opposite" corner
|
|
|
|
|
coordinate>, followed by the next "start" and "opposite" coordinate, etc.
|
|
|
|
|
until all the block information requested has been put into the user's
|
|
|
|
|
buffer.
|
|
|
|
|
No guarantee of any order of the blocks is implied.
|
1999-03-10 18:50:03 -05:00
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
static herr_t
|
1999-03-11 16:03:30 -05:00
|
|
|
|
H5S_get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks, hsize_t *buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
{
|
2000-09-13 16:58:18 -05:00
|
|
|
|
H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */
|
|
|
|
|
hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab counts */
|
|
|
|
|
hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset of element in dataspace */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
hssize_t start[H5O_LAYOUT_NDIMS]; /* Location of start of hyperslab */
|
|
|
|
|
hssize_t end[H5O_LAYOUT_NDIMS]; /* Location of end of hyperslab */
|
2000-10-10 15:55:54 -05:00
|
|
|
|
hssize_t temp_off; /* Offset in a given dimension */
|
2001-08-14 17:09:56 -05:00
|
|
|
|
int i; /* Counter */
|
|
|
|
|
int fast_dim; /* Rank of the fastest changing dimension for the dataspace */
|
|
|
|
|
int temp_dim; /* Temporary rank holder */
|
|
|
|
|
int ndims; /* Rank of the dataspace */
|
|
|
|
|
int done; /* Whether we are done with the iteration */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
herr_t ret_value=SUCCEED; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_get_select_hyper_blocklist, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
assert(buf);
|
|
|
|
|
|
2000-09-13 16:58:18 -05:00
|
|
|
|
/* Check for a "regular" hyperslab selection */
|
|
|
|
|
if(space->select.sel_info.hslab.diminfo != NULL) {
|
|
|
|
|
/* Set some convienence values */
|
|
|
|
|
ndims=space->extent.u.simple.rank;
|
|
|
|
|
fast_dim=ndims-1;
|
2000-09-22 14:28:05 -05:00
|
|
|
|
/*
|
|
|
|
|
* Use the "application dimension information" to pass back to the user
|
|
|
|
|
* the blocks they set, not the optimized, internal information.
|
|
|
|
|
*/
|
|
|
|
|
diminfo=space->select.sel_info.hslab.app_diminfo;
|
2000-09-13 16:58:18 -05:00
|
|
|
|
|
|
|
|
|
/* Build the tables of count sizes as well as the initial offset */
|
|
|
|
|
for(i=0; i<ndims; i++) {
|
|
|
|
|
tmp_count[i]=diminfo[i].count;
|
|
|
|
|
offset[i]=diminfo[i].start;
|
|
|
|
|
} /* end for */
|
|
|
|
|
|
|
|
|
|
/* We're not done with the iteration */
|
|
|
|
|
done=0;
|
|
|
|
|
|
|
|
|
|
/* Go iterate over the hyperslabs */
|
|
|
|
|
while(done==0 && numblocks>0) {
|
|
|
|
|
/* Iterate over the blocks in the fastest dimension */
|
|
|
|
|
while(tmp_count[fast_dim]>0 && numblocks>0) {
|
|
|
|
|
|
|
|
|
|
/* Check if we should copy this block information */
|
|
|
|
|
if(startblock==0) {
|
|
|
|
|
/* Copy the starting location */
|
|
|
|
|
HDmemcpy(buf,offset,sizeof(hsize_t)*ndims);
|
|
|
|
|
buf+=ndims;
|
|
|
|
|
|
|
|
|
|
/* Compute the ending location */
|
|
|
|
|
HDmemcpy(buf,offset,sizeof(hsize_t)*ndims);
|
|
|
|
|
for(i=0; i<ndims; i++)
|
|
|
|
|
buf[i]+=(diminfo[i].block-1);
|
|
|
|
|
buf+=ndims;
|
|
|
|
|
|
|
|
|
|
/* Decrement the number of blocks to retrieve */
|
|
|
|
|
numblocks--;
|
|
|
|
|
} /* end if */
|
|
|
|
|
else
|
|
|
|
|
startblock--;
|
|
|
|
|
|
|
|
|
|
/* Move the offset to the next sequence to start */
|
|
|
|
|
offset[fast_dim]+=diminfo[fast_dim].stride;
|
|
|
|
|
|
|
|
|
|
/* Decrement the block count */
|
|
|
|
|
tmp_count[fast_dim]--;
|
|
|
|
|
} /* end while */
|
|
|
|
|
|
|
|
|
|
/* Work on other dimensions if necessary */
|
|
|
|
|
if(fast_dim>0 && numblocks>0) {
|
|
|
|
|
/* Reset the block counts */
|
|
|
|
|
tmp_count[fast_dim]=diminfo[fast_dim].count;
|
|
|
|
|
|
|
|
|
|
/* Bubble up the decrement to the slower changing dimensions */
|
|
|
|
|
temp_dim=fast_dim-1;
|
|
|
|
|
while(temp_dim>=0 && done==0) {
|
|
|
|
|
/* Decrement the block count */
|
|
|
|
|
tmp_count[temp_dim]--;
|
|
|
|
|
|
|
|
|
|
/* Check if we have more blocks left */
|
|
|
|
|
if(tmp_count[temp_dim]>0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Check for getting out of iterator */
|
|
|
|
|
if(temp_dim==0)
|
|
|
|
|
done=1;
|
|
|
|
|
|
|
|
|
|
/* Reset the block count in this dimension */
|
|
|
|
|
tmp_count[temp_dim]=diminfo[temp_dim].count;
|
|
|
|
|
|
|
|
|
|
/* Wrapped a dimension, go up to next dimension */
|
|
|
|
|
temp_dim--;
|
|
|
|
|
} /* end while */
|
|
|
|
|
} /* end if */
|
|
|
|
|
|
|
|
|
|
/* Re-compute offset array */
|
|
|
|
|
for(i=0; i<ndims; i++) {
|
2001-11-02 15:31:35 -05:00
|
|
|
|
temp_off=diminfo[i].start+diminfo[i].stride*(diminfo[i].count-tmp_count[i]);
|
2000-09-13 16:58:18 -05:00
|
|
|
|
offset[i]=temp_off;
|
|
|
|
|
} /* end for */
|
|
|
|
|
} /* end while */
|
|
|
|
|
} /* end if */
|
|
|
|
|
else {
|
2001-11-02 15:31:35 -05:00
|
|
|
|
ret_value=H5S_hyper_span_blocklist(space->select.sel_info.hslab.span_lst,start,end,(hsize_t)0,&startblock,&numblocks,&buf);
|
2000-09-13 16:58:18 -05:00
|
|
|
|
} /* end else */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
2001-11-02 15:31:35 -05:00
|
|
|
|
} /* H5S_get_select_hyper_blocklist() */
|
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_hyper_blocklist
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the list of hyperslab blocks currently selected
|
|
|
|
|
USAGE
|
2001-11-02 15:31:35 -05:00
|
|
|
|
herr_t H5Sget_select_hyper_blocklist(dsid, startblock, numblocks, buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
1999-03-11 16:03:30 -05:00
|
|
|
|
hsize_t startblock; IN: Hyperslab block to start with
|
|
|
|
|
hsize_t numblocks; IN: Number of hyperslab blocks to get
|
1999-03-10 18:50:03 -05:00
|
|
|
|
hsize_t *buf; OUT: List of hyperslab blocks selected
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
1999-03-12 15:05:43 -05:00
|
|
|
|
Puts a list of the hyperslab blocks into the user's buffer. The blocks
|
|
|
|
|
start with the 'startblock'th block in the list of blocks and put
|
|
|
|
|
'numblocks' number of blocks into the user's buffer (or until the end of
|
|
|
|
|
the list of blocks, whichever happen first)
|
|
|
|
|
The block coordinates have the same dimensionality (rank) as the
|
|
|
|
|
dataspace they are located within. The list of blocks is formatted as
|
|
|
|
|
follows: <"start" coordinate> immediately followed by <"opposite" corner
|
|
|
|
|
coordinate>, followed by the next "start" and "opposite" coordinate, etc.
|
|
|
|
|
until all the block information requested has been put into the user's
|
|
|
|
|
buffer.
|
|
|
|
|
No guarantee of any order of the blocks is implied.
|
1999-03-10 18:50:03 -05:00
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
1999-03-11 16:03:30 -05:00
|
|
|
|
H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock, hsize_t numblocks, hsize_t *buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sget_select_hyper_blocklist, FAIL);
|
1999-03-12 13:35:04 -05:00
|
|
|
|
H5TRACE4("e","ihh*h",spaceid,startblock,numblocks,buf);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(buf==NULL)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer");
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
if(space->select.type!=H5S_SEL_HYPERSLABS)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection");
|
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
/* Go get the correct number of blocks */
|
|
|
|
|
if(numblocks>0)
|
|
|
|
|
ret_value = H5S_get_select_hyper_blocklist(space,startblock,numblocks,buf);
|
|
|
|
|
else
|
|
|
|
|
ret_value=SUCCEED; /* Successfully got 0 blocks... */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_hyper_blocklist() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_get_select_elem_pointlist
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the list of element points currently selected
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_get_select_elem_pointlist(space, hsize_t *buf)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer of selection to query
|
1999-03-11 16:03:30 -05:00
|
|
|
|
hsize_t startpoint; IN: Element point to start with
|
|
|
|
|
hsize_t numpoints; IN: Number of element points to get
|
1999-03-10 18:50:03 -05:00
|
|
|
|
hsize_t *buf; OUT: List of element points selected
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
1999-03-12 15:05:43 -05:00
|
|
|
|
Puts a list of the element points into the user's buffer. The points
|
|
|
|
|
start with the 'startpoint'th block in the list of points and put
|
|
|
|
|
'numpoints' number of points into the user's buffer (or until the end of
|
|
|
|
|
the list of points, whichever happen first)
|
|
|
|
|
The point coordinates have the same dimensionality (rank) as the
|
|
|
|
|
dataspace they are located within. The list of points is formatted as
|
|
|
|
|
follows: <coordinate> followed by the next coordinate, etc. until all the
|
|
|
|
|
point information in the selection have been put into the user's buffer.
|
|
|
|
|
The points are returned in the order they will be interated through
|
|
|
|
|
when a selection is read/written from/to disk.
|
1999-03-10 18:50:03 -05:00
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
static herr_t
|
1999-03-11 16:03:30 -05:00
|
|
|
|
H5S_get_select_elem_pointlist(H5S_t *space, hsize_t startpoint, hsize_t numpoints, hsize_t *buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
{
|
|
|
|
|
H5S_pnt_node_t *node; /* Point node */
|
2001-08-14 17:09:56 -05:00
|
|
|
|
int rank; /* Dataspace rank */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
herr_t ret_value=SUCCEED; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_get_select_elem_pointlist, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
assert(buf);
|
|
|
|
|
|
|
|
|
|
/* Get the dataspace extent rank */
|
|
|
|
|
rank=space->extent.u.simple.rank;
|
|
|
|
|
|
1999-03-11 16:03:30 -05:00
|
|
|
|
/* Get the head of the point list */
|
|
|
|
|
node=space->select.sel_info.pnt_lst->head;
|
|
|
|
|
|
|
|
|
|
/* Iterate to the first point to return */
|
|
|
|
|
while(node!=NULL && startpoint>0) {
|
|
|
|
|
startpoint--;
|
|
|
|
|
node=node->next;
|
|
|
|
|
} /* end while */
|
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
/* Iterate through the node, copying each hyperslab's information */
|
1999-03-11 16:03:30 -05:00
|
|
|
|
while(node!=NULL && numpoints>0) {
|
1999-03-10 18:50:03 -05:00
|
|
|
|
HDmemcpy(buf,node->pnt,sizeof(hsize_t)*rank);
|
|
|
|
|
buf+=rank;
|
1999-03-11 16:03:30 -05:00
|
|
|
|
numpoints--;
|
1999-03-10 18:50:03 -05:00
|
|
|
|
node=node->next;
|
|
|
|
|
} /* end while */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_elem_pointlist() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_elem_pointlist
|
|
|
|
|
PURPOSE
|
|
|
|
|
Get the list of element points currently selected
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5Sget_select_elem_pointlist(dsid, hsize_t *buf)
|
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
1999-03-11 16:03:30 -05:00
|
|
|
|
hsize_t startpoint; IN: Element point to start with
|
|
|
|
|
hsize_t numpoints; IN: Number of element points to get
|
1999-03-10 18:50:03 -05:00
|
|
|
|
hsize_t *buf; OUT: List of element points selected
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
1999-03-12 15:05:43 -05:00
|
|
|
|
Puts a list of the element points into the user's buffer. The points
|
|
|
|
|
start with the 'startpoint'th block in the list of points and put
|
|
|
|
|
'numpoints' number of points into the user's buffer (or until the end of
|
|
|
|
|
the list of points, whichever happen first)
|
|
|
|
|
The point coordinates have the same dimensionality (rank) as the
|
|
|
|
|
dataspace they are located within. The list of points is formatted as
|
|
|
|
|
follows: <coordinate> followed by the next coordinate, etc. until all the
|
|
|
|
|
point information in the selection have been put into the user's buffer.
|
|
|
|
|
The points are returned in the order they will be interated through
|
|
|
|
|
when a selection is read/written from/to disk.
|
1999-03-10 18:50:03 -05:00
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
1999-03-11 16:03:30 -05:00
|
|
|
|
H5Sget_select_elem_pointlist(hid_t spaceid, hsize_t startpoint, hsize_t numpoints, hsize_t *buf)
|
1999-03-10 18:50:03 -05:00
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sget_select_elem_pointlist, FAIL);
|
1999-03-12 13:35:04 -05:00
|
|
|
|
H5TRACE4("e","ihh*h",spaceid,startpoint,numpoints,buf);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(buf==NULL)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer");
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
if(space->select.type!=H5S_SEL_POINTS)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a point selection");
|
|
|
|
|
|
1999-03-11 16:03:30 -05:00
|
|
|
|
ret_value = H5S_get_select_elem_pointlist(space,startpoint,numpoints,buf);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_elem_pointlist() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_get_select_bounds
|
|
|
|
|
PURPOSE
|
|
|
|
|
Gets the bounding box containing the selection.
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_get_select_bounds(space, hsize_t *start, hsize_t *end)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer of selection to query
|
|
|
|
|
hsize_t *start; OUT: Starting coordinate of bounding box
|
|
|
|
|
hsize_t *end; OUT: Opposite coordinate of bounding box
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Retrieves the bounding box containing the current selection and places
|
|
|
|
|
it into the user's buffers. The start and end buffers must be large
|
|
|
|
|
enough to hold the dataspace rank number of coordinates. The bounding box
|
|
|
|
|
exactly contains the selection, ie. if a 2-D element selection is currently
|
|
|
|
|
defined with the following points: (4,5), (6,8) (10,7), the bounding box
|
|
|
|
|
with be (4, 5), (10, 8). Calling this function on a "none" selection
|
|
|
|
|
returns fail.
|
|
|
|
|
The bounding box calculations _does_ include the current offset of the
|
|
|
|
|
selection within the dataspace extent.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
static herr_t
|
|
|
|
|
H5S_get_select_bounds(H5S_t *space, hsize_t *start, hsize_t *end)
|
|
|
|
|
{
|
2001-08-14 17:09:56 -05:00
|
|
|
|
int rank; /* Dataspace rank */
|
|
|
|
|
int i; /* index variable */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_get_select_bounds, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
assert(start);
|
|
|
|
|
assert(end);
|
|
|
|
|
|
2001-11-02 15:31:35 -05:00
|
|
|
|
/* Set the start and end arrays up */
|
1999-03-10 18:50:03 -05:00
|
|
|
|
rank=space->extent.u.simple.rank;
|
|
|
|
|
for(i=0; i<rank; i++) {
|
|
|
|
|
start[i]=UINT_MAX;
|
|
|
|
|
end[i]=0;
|
|
|
|
|
} /* end for */
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_bounds(space,start,end);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_bounds(space,start,end);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_bounds(space,start,end);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
1999-03-11 16:03:30 -05:00
|
|
|
|
} /* H5S_get_select_bounds() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_bounds
|
|
|
|
|
PURPOSE
|
|
|
|
|
Gets the bounding box containing the selection.
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_get_select_bounds(space, start, end)
|
|
|
|
|
hid_t dsid; IN: Dataspace ID of selection to query
|
|
|
|
|
hsize_t *start; OUT: Starting coordinate of bounding box
|
|
|
|
|
hsize_t *end; OUT: Opposite coordinate of bounding box
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success, negative on failure
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Retrieves the bounding box containing the current selection and places
|
|
|
|
|
it into the user's buffers. The start and end buffers must be large
|
|
|
|
|
enough to hold the dataspace rank number of coordinates. The bounding box
|
|
|
|
|
exactly contains the selection, ie. if a 2-D element selection is currently
|
|
|
|
|
defined with the following points: (4,5), (6,8) (10,7), the bounding box
|
|
|
|
|
with be (4, 5), (10, 8). Calling this function on a "none" selection
|
|
|
|
|
returns fail.
|
|
|
|
|
The bounding box calculations _does_ include the current offset of the
|
|
|
|
|
selection within the dataspace extent.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
|
|
|
|
H5Sget_select_bounds(hid_t spaceid, hsize_t *start, hsize_t *end)
|
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* Dataspace to modify selection of */
|
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5Sget_select_bounds, FAIL);
|
1999-03-12 13:35:04 -05:00
|
|
|
|
H5TRACE3("e","i*h*h",spaceid,start,end);
|
1999-03-10 18:50:03 -05:00
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if(start==NULL || end==NULL)
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer");
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(spaceid) ||
|
|
|
|
|
NULL == (space=H5I_object(spaceid))) {
|
|
|
|
|
HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret_value = H5S_get_select_bounds(space,start,end);
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5Sget_select_bounds() */
|
2001-11-02 15:31:35 -05:00
|
|
|
|
|
1999-05-25 16:29:31 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_contiguous
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check if the selection is contiguous within the dataspace extent.
|
|
|
|
|
USAGE
|
|
|
|
|
htri_t H5S_select_contiguous(space)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer to check
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE/FALSE/FAIL
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Checks to see if the current selection in the dataspace is contiguous.
|
|
|
|
|
This is primarily used for reading the entire selection in one swoop.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
htri_t
|
|
|
|
|
H5S_select_contiguous(const H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
htri_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_contiguous, FAIL);
|
|
|
|
|
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_contiguous(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_contiguous(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=TRUE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=FALSE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_contiguous() */
|
1999-06-23 21:16:13 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
2002-04-09 07:47:34 -05:00
|
|
|
|
H5S_select_iterate
|
1999-06-23 21:16:13 -05:00
|
|
|
|
PURPOSE
|
|
|
|
|
Iterate over the selected elements in a memory buffer.
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_iterate(buf, type_id, space, operator, operator_data)
|
|
|
|
|
void *buf; IN/OUT: Buffer containing elements to iterate over
|
|
|
|
|
hid_t type_id; IN: Datatype ID of BUF array.
|
|
|
|
|
H5S_t *space; IN: Dataspace object containing selection to iterate over
|
1999-08-10 13:54:06 -05:00
|
|
|
|
H5D_operator_t op; IN: Function pointer to the routine to be
|
1999-06-23 21:16:13 -05:00
|
|
|
|
called for each element in BUF iterated over.
|
|
|
|
|
void *operator_data; IN/OUT: Pointer to any user-defined data
|
|
|
|
|
associated with the operation.
|
|
|
|
|
RETURNS
|
|
|
|
|
Returns the return value of the last operator if it was non-zero, or zero
|
|
|
|
|
if all elements were processed. Otherwise returns a negative value.
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Iterates over the selected elements in a memory buffer, calling the user's
|
|
|
|
|
callback function for each element. The selection in the dataspace is
|
|
|
|
|
modified so that any elements already iterated over are removed from the
|
|
|
|
|
selection if the iteration is interrupted (by the H5D_operator_t function
|
|
|
|
|
returning non-zero) in the "middle" of the iteration and may be re-started
|
|
|
|
|
by the user where it left off.
|
|
|
|
|
|
|
|
|
|
NOTE: Until "subtracting" elements from a selection is implemented,
|
|
|
|
|
the selection is not modified.
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
1999-08-10 13:54:06 -05:00
|
|
|
|
H5S_select_iterate(void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op,
|
1999-06-23 21:16:13 -05:00
|
|
|
|
void *operator_data)
|
|
|
|
|
{
|
|
|
|
|
herr_t ret_value=FAIL;
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER(H5S_select_iterate, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert(buf);
|
|
|
|
|
assert(space);
|
1999-08-10 13:54:06 -05:00
|
|
|
|
assert(op);
|
1999-06-25 14:36:54 -05:00
|
|
|
|
assert(H5I_DATATYPE == H5I_get_type(type_id));
|
1999-06-23 21:16:13 -05:00
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
1999-08-10 13:54:06 -05:00
|
|
|
|
ret_value=H5S_point_select_iterate(buf,type_id,space,op,operator_data);
|
1999-06-23 21:16:13 -05:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
1999-08-10 13:54:06 -05:00
|
|
|
|
ret_value=H5S_hyper_select_iterate(buf,type_id,space,op,operator_data);
|
1999-06-23 21:16:13 -05:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
1999-08-10 13:54:06 -05:00
|
|
|
|
ret_value=H5S_all_select_iterate(buf,type_id,space,op,operator_data);
|
1999-06-23 21:16:13 -05:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
1999-08-10 13:54:06 -05:00
|
|
|
|
ret_value=H5S_none_select_iterate(buf,type_id,space,op,operator_data);
|
1999-06-23 21:16:13 -05:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
1999-06-25 14:36:54 -05:00
|
|
|
|
FUNC_LEAVE(ret_value);
|
1999-06-23 21:16:13 -05:00
|
|
|
|
} /* end H5S_select_iterate() */
|
|
|
|
|
|
2002-02-07 11:21:24 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5Sget_select_type
|
|
|
|
|
PURPOSE
|
|
|
|
|
Retrieve the type of selection in a dataspace
|
|
|
|
|
USAGE
|
|
|
|
|
H5S_sel_type H5Sget_select_type(space_id)
|
|
|
|
|
hid_t space_id; IN: Dataspace object to reset
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success/Negative on failure. Return value is from the
|
|
|
|
|
set of values in the H5S_sel_type enumerated type.
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
This function retrieves the type of selection currently defined for
|
|
|
|
|
a dataspace.
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
H5S_sel_type
|
|
|
|
|
H5Sget_select_type(hid_t space_id)
|
|
|
|
|
{
|
|
|
|
|
H5S_t *space = NULL; /* dataspace to modify */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER(H5Sget_select_type, H5S_SEL_ERROR);
|
|
|
|
|
H5TRACE1("St","i",space_id);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
if (H5I_DATASPACE != H5I_get_type(space_id) || NULL == (space = H5I_object(space_id)))
|
|
|
|
|
HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, H5S_SEL_ERROR, "not a data space");
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE(space->select.type);
|
|
|
|
|
} /* end H5Sget_select_type() */
|
|
|
|
|
|
2002-04-02 15:51:41 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_single
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check if the selection is a single block within the dataspace extent.
|
|
|
|
|
USAGE
|
|
|
|
|
htri_t H5S_select_single(space)
|
|
|
|
|
H5S_t *space; IN: Dataspace pointer to check
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE/FALSE/FAIL
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Checks to see if the current selection in the dataspace is a single block.
|
|
|
|
|
This is primarily used for reading the entire selection in one swoop.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
htri_t
|
|
|
|
|
H5S_select_single(const H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
htri_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_single, FAIL);
|
|
|
|
|
|
2002-04-03 12:07:14 -05:00
|
|
|
|
/* Check args */
|
2002-04-02 15:51:41 -05:00
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_single(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_single(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=TRUE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=FALSE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_single() */
|
|
|
|
|
|
2002-04-03 12:07:14 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_shape_same
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check if two selections are the same shape
|
|
|
|
|
USAGE
|
|
|
|
|
htri_t H5S_select_shape_same(space1, space2)
|
|
|
|
|
const H5S_t *space1; IN: 1st Dataspace pointer to compare
|
|
|
|
|
const H5S_t *space2; IN: 2nd Dataspace pointer to compare
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE/FALSE/FAIL
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Checks to see if the current selection in the dataspaces are the same
|
|
|
|
|
dimensionality and shape.
|
|
|
|
|
This is primarily used for reading the entire selection in one swoop.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
Assumes that there is only a single "block" for hyperslab selections.
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
htri_t
|
|
|
|
|
H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
|
|
|
|
|
{
|
|
|
|
|
H5S_hyper_span_t *span1=NULL,*span2=NULL; /* Hyperslab span node */
|
|
|
|
|
hsize_t elmts1,elmts2; /* Number of elements in each dimension of selection */
|
|
|
|
|
unsigned u; /* Index variable */
|
|
|
|
|
htri_t ret_value=TRUE; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_shape_same, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert(space1);
|
|
|
|
|
assert(space2);
|
|
|
|
|
|
|
|
|
|
if (space1->extent.u.simple.rank!=space2->extent.u.simple.rank)
|
|
|
|
|
HGOTO_DONE(FALSE);
|
|
|
|
|
|
|
|
|
|
/* Get information about memory and file */
|
|
|
|
|
for (u=0; u<space1->extent.u.simple.rank; u++) {
|
|
|
|
|
switch(space1->select.type) {
|
|
|
|
|
case H5S_SEL_HYPERSLABS:
|
|
|
|
|
/* Check size hyperslab selection in this dimension */
|
|
|
|
|
if(space1->select.sel_info.hslab.diminfo != NULL) {
|
|
|
|
|
elmts1=space1->select.sel_info.hslab.diminfo[u].block;
|
|
|
|
|
} /* end if */
|
|
|
|
|
else {
|
|
|
|
|
/* Check for the first dimension */
|
|
|
|
|
if(span1==NULL)
|
|
|
|
|
span1=space1->select.sel_info.hslab.span_lst->head;
|
|
|
|
|
|
|
|
|
|
/* Get the number of elements in the span */
|
|
|
|
|
elmts1=(span1->high-span1->low)+1;
|
|
|
|
|
|
|
|
|
|
/* Advance to the next dimension */
|
|
|
|
|
span1=span1->down->head;
|
|
|
|
|
} /* end else */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL:
|
|
|
|
|
elmts1=space1->extent.u.simple.size[u];
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_POINTS:
|
|
|
|
|
elmts1=1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
assert(0 && "Invalid selection type!");
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
switch(space2->select.type) {
|
|
|
|
|
case H5S_SEL_HYPERSLABS:
|
|
|
|
|
/* Check size hyperslab selection in this dimension */
|
|
|
|
|
if(space2->select.sel_info.hslab.diminfo != NULL) {
|
|
|
|
|
elmts2=space2->select.sel_info.hslab.diminfo[u].block;
|
|
|
|
|
} /* end if */
|
|
|
|
|
else {
|
|
|
|
|
/* Check for the first dimension */
|
|
|
|
|
if(span2==NULL)
|
|
|
|
|
span2=space2->select.sel_info.hslab.span_lst->head;
|
|
|
|
|
|
|
|
|
|
/* Get the number of elements in the span */
|
|
|
|
|
elmts2=(span2->high-span2->low)+1;
|
|
|
|
|
|
|
|
|
|
/* Advance to the next dimension */
|
|
|
|
|
span2=span2->down->head;
|
|
|
|
|
} /* end else */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL:
|
|
|
|
|
elmts2=space2->extent.u.simple.size[u];
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_POINTS:
|
|
|
|
|
elmts2=1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
assert(0 && "Invalid selection type!");
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
/* Make certaint the selections have the same number of elements in this dimension */
|
|
|
|
|
if (elmts1!=elmts2)
|
|
|
|
|
HGOTO_DONE(FALSE);
|
|
|
|
|
} /* end for */
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_shape_same() */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_regular
|
|
|
|
|
PURPOSE
|
|
|
|
|
Check if a selection is "regular"
|
|
|
|
|
USAGE
|
|
|
|
|
htri_t H5S_select_regular(space)
|
|
|
|
|
const H5S_t *space; IN: Dataspace pointer to check
|
|
|
|
|
RETURNS
|
|
|
|
|
TRUE/FALSE/FAIL
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Checks to see if the current selection in a dataspace is the a regular
|
|
|
|
|
pattern.
|
|
|
|
|
This is primarily used for reading the entire selection in one swoop.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
htri_t
|
|
|
|
|
H5S_select_regular(const H5S_t *space)
|
|
|
|
|
{
|
|
|
|
|
htri_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_regular, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert(space);
|
|
|
|
|
|
|
|
|
|
/* Check for a "regular" selection */
|
|
|
|
|
/* [Defer (mostly) to the selection routines] */
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_regular(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_regular(space);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=TRUE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=FALSE;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_regular() */
|
|
|
|
|
|
2002-04-09 07:47:34 -05:00
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------
|
|
|
|
|
NAME
|
|
|
|
|
H5S_select_fill
|
|
|
|
|
PURPOSE
|
|
|
|
|
Fill a selection in memory with a value
|
|
|
|
|
USAGE
|
|
|
|
|
herr_t H5S_select_fill(fill,fill_size,space,buf)
|
|
|
|
|
const void *fill; IN: Pointer to fill value to use
|
|
|
|
|
size_t fill_size; IN: Size of elements in memory buffer & size of
|
|
|
|
|
fill value
|
|
|
|
|
H5S_t *space; IN: Dataspace describing memory buffer &
|
|
|
|
|
containing selection to use.
|
|
|
|
|
void *buf; IN/OUT: Memory buffer to fill selection in
|
|
|
|
|
RETURNS
|
|
|
|
|
Non-negative on success/Negative on failure.
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Use the selection in the dataspace to fill elements in a memory buffer.
|
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
|
COMMENTS, BUGS, ASSUMPTIONS
|
|
|
|
|
The memory buffer elements are assumed to have the same datatype as the
|
|
|
|
|
fill value being placed into them.
|
|
|
|
|
EXAMPLES
|
|
|
|
|
REVISION LOG
|
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
|
herr_t
|
2002-04-11 17:52:48 -05:00
|
|
|
|
H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *buf)
|
2002-04-09 07:47:34 -05:00
|
|
|
|
{
|
|
|
|
|
herr_t ret_value=FAIL; /* return value */
|
|
|
|
|
|
|
|
|
|
FUNC_ENTER (H5S_select_fill, FAIL);
|
|
|
|
|
|
|
|
|
|
/* Check args */
|
|
|
|
|
assert(fill);
|
|
|
|
|
assert(fill_size>0);
|
|
|
|
|
assert(space);
|
|
|
|
|
assert(buf);
|
|
|
|
|
|
|
|
|
|
/* Fill the selection in the memory buffer */
|
|
|
|
|
/* [Defer (mostly) to the selection routines] */
|
|
|
|
|
switch(space->select.type) {
|
|
|
|
|
case H5S_SEL_POINTS: /* Sequence of points selected */
|
|
|
|
|
ret_value=H5S_point_select_fill(fill,fill_size,space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
|
|
|
|
ret_value=H5S_hyper_select_fill(fill,fill_size,space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ALL: /* Entire extent selected */
|
|
|
|
|
ret_value=H5S_all_select_fill(fill,fill_size,space,buf);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_NONE: /* Nothing selected */
|
|
|
|
|
ret_value=SUCCEED;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case H5S_SEL_ERROR:
|
|
|
|
|
case H5S_SEL_N:
|
|
|
|
|
assert(0 && "Invalid selection type!");
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
FUNC_LEAVE (ret_value);
|
|
|
|
|
} /* H5S_select_fill() */
|
|
|
|
|
|